--- /dev/null
--- /dev/null
++From 092a59997a1e1d5f421a0a5f87ee655ad173b93f Mon Sep 17 00:00:00 2001
++From: Johannes Demel <demel@uni-bremen.de>
++Date: Sun, 23 Feb 2020 15:03:47 +0100
++Subject: [PATCH 3/7] clang-format: Apply clang-format
++
++This commit adds `.clang-format` from GNU Radio and apply clang-format.
++
++Run:
++`find . -regex '.*\.\(c\|cc\|cpp\|cxx\|h\|hh\)' -exec clang-format \
++-style=file -i {} \;`
++in `.`.
++---
++ .clang-format | 106 ++
++ apps/volk-config-info.cc | 77 +-
++ apps/volk_option_helpers.cc | 268 +--
++ apps/volk_option_helpers.h | 84 +-
++ apps/volk_profile.cc | 205 ++-
++ apps/volk_profile.h | 20 +-
++ cmake/msvc/config.h | 27 +-
++ cmake/msvc/sys/time.h | 77 +-
++ include/volk/saturation_arithmetic.h | 16 +-
++ include/volk/volk_alloc.hh | 42 +-
++ include/volk/volk_avx2_intrinsics.h | 114 +-
++ include/volk/volk_avx_intrinsics.h | 193 +-
++ include/volk/volk_common.h | 148 +-
++ include/volk/volk_complex.h | 41 +-
++ include/volk/volk_malloc.h | 12 +-
++ include/volk/volk_neon_intrinsics.h | 115 +-
++ include/volk/volk_prefs.h | 17 +-
++ include/volk/volk_sse3_intrinsics.h | 79 +-
++ include/volk/volk_sse_intrinsics.h | 53 +-
++ kernels/volk/volk_16i_32fc_dot_prod_32fc.h | 1118 ++++++------
++ kernels/volk/volk_16i_branch_4_state_8.h | 219 ++-
++ kernels/volk/volk_16i_convert_8i.h | 301 ++--
++ kernels/volk/volk_16i_max_star_16i.h | 158 +-
++ .../volk/volk_16i_max_star_horizontal_16i.h | 214 +--
++ .../volk/volk_16i_permute_and_scalar_add.h | 187 +-
++ kernels/volk/volk_16i_s32f_convert_32f.h | 609 +++----
++ kernels/volk/volk_16i_x4_quad_max_star_16i.h | 357 ++--
++ kernels/volk/volk_16i_x5_add_quad_16i_x4.h | 336 ++--
++ kernels/volk/volk_16ic_convert_32fc.h | 241 +--
++ kernels/volk/volk_16ic_deinterleave_16i_x2.h | 431 +++--
++ .../volk/volk_16ic_deinterleave_real_16i.h | 397 +++--
++ kernels/volk/volk_16ic_deinterleave_real_8i.h | 469 +++--
++ kernels/volk/volk_16ic_magnitude_16i.h | 506 +++---
++ .../volk/volk_16ic_s32f_deinterleave_32f_x2.h | 418 ++---
++ .../volk_16ic_s32f_deinterleave_real_32f.h | 372 ++--
++ kernels/volk/volk_16ic_s32f_magnitude_32f.h | 381 ++--
++ kernels/volk/volk_16ic_x2_dot_prod_16ic.h | 750 ++++----
++ kernels/volk/volk_16ic_x2_multiply_16ic.h | 504 ++++--
++ kernels/volk/volk_16u_byteswap.h | 378 ++--
++ kernels/volk/volk_16u_byteswappuppet_16u.h | 44 +-
++ kernels/volk/volk_32f_64f_add_64f.h | 270 +--
++ kernels/volk/volk_32f_64f_multiply_64f.h | 154 +-
++ kernels/volk/volk_32f_8u_polarbutterfly_32f.h | 478 ++---
++ .../volk_32f_8u_polarbutterflypuppet_32f.h | 155 +-
++ kernels/volk/volk_32f_accumulator_s32f.h | 287 +--
++ kernels/volk/volk_32f_acos_32f.h | 700 ++++----
++ kernels/volk/volk_32f_asin_32f.h | 647 +++----
++ kernels/volk/volk_32f_atan_32f.h | 625 +++----
++ kernels/volk/volk_32f_binary_slicer_32i.h | 259 +--
++ kernels/volk/volk_32f_binary_slicer_8i.h | 706 ++++----
++ kernels/volk/volk_32f_convert_64f.h | 214 ++-
++ kernels/volk/volk_32f_cos_32f.h | 1159 ++++++------
++ kernels/volk/volk_32f_expfast_32f.h | 347 ++--
++ kernels/volk/volk_32f_index_max_16u.h | 370 ++--
++ kernels/volk/volk_32f_index_max_32u.h | 770 ++++----
++ kernels/volk/volk_32f_invsqrt_32f.h | 189 +-
++ kernels/volk/volk_32f_log2_32f.h | 719 +++++---
++ kernels/volk/volk_32f_null_32f.h | 16 +-
++ .../volk/volk_32f_s32f_32f_fm_detect_32f.h | 457 ++---
++ ...k_32f_s32f_calc_spectral_noise_floor_32f.h | 683 +++----
++ kernels/volk/volk_32f_s32f_convert_16i.h | 815 ++++-----
++ kernels/volk/volk_32f_s32f_convert_32i.h | 579 +++---
++ kernels/volk/volk_32f_s32f_convert_8i.h | 642 +++----
++ .../volk/volk_32f_s32f_mod_rangepuppet_32f.h | 63 +-
++ kernels/volk/volk_32f_s32f_multiply_32f.h | 271 +--
++ kernels/volk/volk_32f_s32f_normalize.h | 150 +-
++ kernels/volk/volk_32f_s32f_power_32f.h | 166 +-
++ .../volk/volk_32f_s32f_s32f_mod_range_32f.h | 718 ++++----
++ kernels/volk/volk_32f_s32f_stddev_32f.h | 449 ++---
++ kernels/volk/volk_32f_sin_32f.h | 945 +++++-----
++ kernels/volk/volk_32f_sqrt_32f.h | 153 +-
++ .../volk/volk_32f_stddev_and_mean_32f_x2.h | 583 +++---
++ kernels/volk/volk_32f_tan_32f.h | 1023 ++++++-----
++ kernels/volk/volk_32f_tanh_32f.h | 631 ++++---
++ kernels/volk/volk_32f_x2_add_32f.h | 412 +++--
++ kernels/volk/volk_32f_x2_divide_32f.h | 364 ++--
++ kernels/volk/volk_32f_x2_dot_prod_16i.h | 1092 ++++++------
++ kernels/volk/volk_32f_x2_dot_prod_32f.h | 1186 +++++++------
++ .../volk/volk_32f_x2_fm_detectpuppet_32f.h | 40 +-
++ kernels/volk/volk_32f_x2_interleave_32fc.h | 292 +--
++ kernels/volk/volk_32f_x2_max_32f.h | 345 ++--
++ kernels/volk/volk_32f_x2_min_32f.h | 347 ++--
++ kernels/volk/volk_32f_x2_multiply_32f.h | 375 ++--
++ kernels/volk/volk_32f_x2_pow_32f.h | 1175 ++++++------
++ .../volk/volk_32f_x2_s32f_interleave_16ic.h | 324 ++--
++ kernels/volk/volk_32f_x2_subtract_32f.h | 319 ++--
++ kernels/volk/volk_32f_x3_sum_of_poly_32f.h | 1026 +++++------
++ kernels/volk/volk_32fc_32f_add_32fc.h | 281 +--
++ kernels/volk/volk_32fc_32f_dot_prod_32fc.h | 1205 +++++++------
++ kernels/volk/volk_32fc_32f_multiply_32fc.h | 226 +--
++ kernels/volk/volk_32fc_conjugate_32fc.h | 233 +--
++ kernels/volk/volk_32fc_convert_16ic.h | 439 ++---
++ kernels/volk/volk_32fc_deinterleave_32f_x2.h | 297 ++--
++ kernels/volk/volk_32fc_deinterleave_64f_x2.h | 439 ++---
++ .../volk/volk_32fc_deinterleave_imag_32f.h | 210 +--
++ .../volk/volk_32fc_deinterleave_real_32f.h | 214 +--
++ .../volk/volk_32fc_deinterleave_real_64f.h | 262 +--
++ kernels/volk/volk_32fc_index_max_16u.h | 639 +++----
++ kernels/volk/volk_32fc_index_max_32u.h | 630 +++----
++ kernels/volk/volk_32fc_magnitude_32f.h | 556 +++---
++ .../volk/volk_32fc_magnitude_squared_32f.h | 443 ++---
++ kernels/volk/volk_32fc_s32f_atan2_32f.h | 208 +--
++ .../volk_32fc_s32f_deinterleave_real_16i.h | 226 +--
++ kernels/volk/volk_32fc_s32f_magnitude_16i.h | 297 ++--
++ kernels/volk/volk_32fc_s32f_power_32fc.h | 121 +-
++ .../volk/volk_32fc_s32f_power_spectrum_32f.h | 176 +-
++ ..._32fc_s32f_x2_power_spectral_density_32f.h | 297 ++--
++ kernels/volk/volk_32fc_s32fc_multiply_32fc.h | 250 +--
++ .../volk/volk_32fc_s32fc_rotatorpuppet_32fc.h | 118 +-
++ .../volk/volk_32fc_s32fc_x2_rotator_32fc.h | 260 +--
++ kernels/volk/volk_32fc_x2_add_32fc.h | 274 +--
++ .../volk_32fc_x2_conjugate_dot_prod_32fc.h | 1017 ++++++-----
++ kernels/volk/volk_32fc_x2_divide_32fc.h | 372 ++--
++ kernels/volk/volk_32fc_x2_dot_prod_32fc.h | 1334 +++++++-------
++ kernels/volk/volk_32fc_x2_multiply_32fc.h | 575 +++---
++ .../volk_32fc_x2_multiply_conjugate_32fc.h | 347 ++--
++ ...32fc_x2_s32f_square_dist_scalar_mult_32f.h | 657 +++----
++ ...2fc_x2_s32fc_multiply_conjugate_add_32fc.h | 98 +-
++ kernels/volk/volk_32fc_x2_square_dist_32f.h | 426 ++---
++ kernels/volk/volk_32i_s32f_convert_32f.h | 347 ++--
++ kernels/volk/volk_32i_x2_and_32i.h | 320 ++--
++ kernels/volk/volk_32i_x2_or_32i.h | 321 ++--
++ kernels/volk/volk_32u_byteswap.h | 433 ++---
++ kernels/volk/volk_32u_byteswappuppet_32u.h | 44 +-
++ kernels/volk/volk_32u_popcnt.h | 26 +-
++ kernels/volk/volk_32u_popcntpuppet_32u.h | 18 +-
++ kernels/volk/volk_32u_reverse_32u.h | 598 ++++---
++ kernels/volk/volk_64f_convert_32f.h | 324 ++--
++ kernels/volk/volk_64f_x2_add_64f.h | 207 +--
++ kernels/volk/volk_64f_x2_max_64f.h | 276 +--
++ kernels/volk/volk_64f_x2_min_64f.h | 275 +--
++ kernels/volk/volk_64f_x2_multiply_64f.h | 207 +--
++ kernels/volk/volk_64u_byteswap.h | 599 ++++---
++ kernels/volk/volk_64u_byteswappuppet_64u.h | 56 +-
++ kernels/volk/volk_64u_popcnt.h | 79 +-
++ kernels/volk/volk_64u_popcntpuppet_64u.h | 29 +-
++ kernels/volk/volk_8i_convert_16i.h | 315 ++--
++ kernels/volk/volk_8i_s32f_convert_32f.h | 528 +++---
++ kernels/volk/volk_8ic_deinterleave_16i_x2.h | 493 ++++--
++ kernels/volk/volk_8ic_deinterleave_real_16i.h | 346 ++--
++ kernels/volk/volk_8ic_deinterleave_real_8i.h | 482 +++--
++ .../volk/volk_8ic_s32f_deinterleave_32f_x2.h | 571 +++---
++ .../volk_8ic_s32f_deinterleave_real_32f.h | 395 +++--
++ .../volk_8ic_x2_multiply_conjugate_16ic.h | 413 +++--
++ ...volk_8ic_x2_s32f_multiply_conjugate_32fc.h | 496 +++---
++ kernels/volk/volk_8u_conv_k7_r2puppet_8u.h | 494 +++---
++ kernels/volk/volk_8u_x2_encodeframepolar_8u.h | 1569 +++++++++++------
++ kernels/volk/volk_8u_x3_encodepolar_8u_x2.h | 110 +-
++ .../volk/volk_8u_x3_encodepolarpuppet_8u.h | 137 +-
++ kernels/volk/volk_8u_x4_conv_k7_r2_8u.h | 1067 +++++------
++ lib/kernel_tests.h | 257 +--
++ lib/qa_utils.cc | 751 +++++---
++ lib/qa_utils.h | 288 +--
++ lib/testqa.cc | 96 +-
++ lib/volk_malloc.c | 55 +-
++ lib/volk_prefs.c | 74 +-
++ lib/volk_rank_archs.c | 73 +-
++ lib/volk_rank_archs.h | 22 +-
++ 158 files changed, 32509 insertions(+), 27583 deletions(-)
++ create mode 100644 .clang-format
++
++diff --git a/.clang-format b/.clang-format
++new file mode 100644
++index 0000000..285b68d
++--- /dev/null
+++++ b/.clang-format
++@@ -0,0 +1,106 @@
+++---
+++Language: Cpp
+++# BasedOnStyle: LLVM
+++AccessModifierOffset: -4
+++AlignAfterOpenBracket: Align
+++AlignConsecutiveAssignments: false
+++AlignConsecutiveDeclarations: false
+++AlignEscapedNewlinesLeft: true
+++AlignOperands: true
+++AlignTrailingComments: true
+++AllowAllParametersOfDeclarationOnNextLine: true
+++AllowShortBlocksOnASingleLine: false
+++AllowShortCaseLabelsOnASingleLine: false
+++AllowShortFunctionsOnASingleLine: All
+++AllowShortIfStatementsOnASingleLine: false
+++AllowShortLoopsOnASingleLine: false
+++AlwaysBreakAfterDefinitionReturnType: None
+++AlwaysBreakAfterReturnType: None
+++AlwaysBreakBeforeMultilineStrings: false
+++AlwaysBreakTemplateDeclarations: true
+++BinPackArguments: false
+++BinPackParameters: false
+++BreakBeforeBraces: Custom
+++BraceWrapping:
+++ AfterClass: true
+++ AfterControlStatement: false
+++ AfterEnum: false
+++ AfterFunction: true
+++ AfterNamespace: false
+++ AfterObjCDeclaration: false
+++ AfterStruct: false
+++ AfterUnion: false
+++ BeforeCatch: false
+++ BeforeElse: false
+++ IndentBraces: false
+++BreakBeforeBinaryOperators: None
+++BreakBeforeTernaryOperators: true
+++BreakConstructorInitializersBeforeComma: false
+++BreakAfterJavaFieldAnnotations: false
+++BreakStringLiterals: true
+++ColumnLimit: 90
+++CommentPragmas: '^ IWYU pragma:'
+++ConstructorInitializerAllOnOneLineOrOnePerLine: true
+++ConstructorInitializerIndentWidth: 4
+++ContinuationIndentWidth: 4
+++Cpp11BracedListStyle: false
+++DerivePointerAlignment: false
+++DisableFormat: false
+++ExperimentalAutoDetectBinPacking: false
+++ForEachMacros:
+++ - foreach
+++ - Q_FOREACH
+++ - BOOST_FOREACH
+++IncludeCategories:
+++ - Regex: '^"(gnuradio)/'
+++ Priority: 1
+++ - Regex: '^<(gnuradio)/'
+++ Priority: 2
+++ - Regex: '^<(boost)/'
+++ Priority: 98
+++ - Regex: '^<[a-z]*>$'
+++ Priority: 99
+++ - Regex: '^".*"$'
+++ Priority: 0
+++ - Regex: '.*'
+++ Priority: 10
+++
+++IncludeIsMainRegex: '(Test)?$'
+++IndentCaseLabels: false
+++IndentWidth: 4
+++IndentWrappedFunctionNames: false
+++JavaScriptQuotes: Leave
+++JavaScriptWrapImports: true
+++KeepEmptyLinesAtTheStartOfBlocks: true
+++MacroBlockBegin: ''
+++MacroBlockEnd: ''
+++MaxEmptyLinesToKeep: 2
+++NamespaceIndentation: None
+++ObjCBlockIndentWidth: 2
+++ObjCSpaceAfterProperty: false
+++ObjCSpaceBeforeProtocolList: true
+++PenaltyBreakBeforeFirstCallParameter: 19
+++PenaltyBreakComment: 300
+++PenaltyBreakFirstLessLess: 120
+++PenaltyBreakString: 1000
+++PenaltyExcessCharacter: 1000000
+++PenaltyReturnTypeOnItsOwnLine: 60
+++PointerAlignment: Left
+++ReflowComments: true
+++SortIncludes: true
+++SpaceAfterCStyleCast: false
+++SpaceAfterTemplateKeyword: true
+++SpaceBeforeAssignmentOperators: true
+++SpaceBeforeParens: ControlStatements
+++SpaceInEmptyParentheses: false
+++SpacesBeforeTrailingComments: 1
+++SpacesInAngles: false
+++SpacesInContainerLiterals: true
+++SpacesInCStyleCastParentheses: false
+++SpacesInParentheses: false
+++SpacesInSquareBrackets: false
+++Standard: Cpp11
+++TabWidth: 8
+++UseTab: Never
+++
+++
++diff --git a/apps/volk-config-info.cc b/apps/volk-config-info.cc
++index 4eedcb7..2521993 100644
++--- a/apps/volk-config-info.cc
+++++ b/apps/volk-config-info.cc
++@@ -24,52 +24,63 @@
++ #include <config.h>
++ #endif
++
++-#include <volk/constants.h> // for volk_available_machines, volk_c_com...
++-#include <iostream> // for operator<<, endl, cout, ostream
++-#include <string> // for string
+++#include <volk/constants.h> // for volk_available_machines, volk_c_com...
+++#include <iostream> // for operator<<, endl, cout, ostream
+++#include <string> // for string
++
++-#include "volk/volk.h" // for volk_get_alignment, volk_get_machine
++-#include "volk_option_helpers.h" // for option_list, option_t
+++#include "volk/volk.h" // for volk_get_alignment, volk_get_machine
+++#include "volk_option_helpers.h" // for option_list, option_t
++
++ void print_alignment()
++ {
++- std::cout << "Alignment in bytes: " << volk_get_alignment() << std::endl;
+++ std::cout << "Alignment in bytes: " << volk_get_alignment() << std::endl;
++ }
++
++ void print_malloc()
++ {
++- // You don't want to change the volk_malloc code, so just copy the if/else
++- // structure from there and give an explanation for the implementations
++- std::cout << "Used malloc implementation: ";
++- #if HAVE_POSIX_MEMALIGN
++- std::cout << "posix_memalign" << std::endl;
++- #elif defined(_MSC_VER)
++- std::cout << "_aligned_malloc" << std::endl;
++- #else
++- std::cout << "C11 aligned_alloc" << std::endl;
++- #endif
+++ // You don't want to change the volk_malloc code, so just copy the if/else
+++ // structure from there and give an explanation for the implementations
+++ std::cout << "Used malloc implementation: ";
+++#if HAVE_POSIX_MEMALIGN
+++ std::cout << "posix_memalign" << std::endl;
+++#elif defined(_MSC_VER)
+++ std::cout << "_aligned_malloc" << std::endl;
+++#else
+++ std::cout << "C11 aligned_alloc" << std::endl;
+++#endif
++ }
++
++
++-int
++-main(int argc, char **argv)
+++int main(int argc, char** argv)
++ {
++
++- option_list our_options("volk-config-info");
++- our_options.add(option_t("prefix", "", "print the VOLK installation prefix", volk_prefix()));
++- our_options.add(option_t("cc", "", "print the VOLK C compiler version", volk_c_compiler()));
++- our_options.add(option_t("cflags", "", "print the VOLK CFLAGS", volk_compiler_flags()));
++- our_options.add(option_t("all-machines", "", "print VOLK machines built", volk_available_machines()));
++- our_options.add(option_t("avail-machines", "", "print VOLK machines on the current "
++- "platform", volk_list_machines));
++- our_options.add(option_t("machine", "", "print the current VOLK machine that will be used",
++- volk_get_machine()));
++- our_options.add(option_t("alignment", "", "print the memory alignment", print_alignment));
++- our_options.add(option_t("malloc", "", "print the malloc implementation used in volk_malloc",
++- print_malloc));
++- our_options.add(option_t("version", "v", "print the VOLK version", volk_version()));
+++ option_list our_options("volk-config-info");
+++ our_options.add(
+++ option_t("prefix", "", "print the VOLK installation prefix", volk_prefix()));
+++ our_options.add(
+++ option_t("cc", "", "print the VOLK C compiler version", volk_c_compiler()));
+++ our_options.add(
+++ option_t("cflags", "", "print the VOLK CFLAGS", volk_compiler_flags()));
+++ our_options.add(option_t(
+++ "all-machines", "", "print VOLK machines built", volk_available_machines()));
+++ our_options.add(option_t("avail-machines",
+++ "",
+++ "print VOLK machines on the current "
+++ "platform",
+++ volk_list_machines));
+++ our_options.add(option_t("machine",
+++ "",
+++ "print the current VOLK machine that will be used",
+++ volk_get_machine()));
+++ our_options.add(
+++ option_t("alignment", "", "print the memory alignment", print_alignment));
+++ our_options.add(option_t("malloc",
+++ "",
+++ "print the malloc implementation used in volk_malloc",
+++ print_malloc));
+++ our_options.add(option_t("version", "v", "print the VOLK version", volk_version()));
++
++- our_options.parse(argc, argv);
+++ our_options.parse(argc, argv);
++
++- return 0;
+++ return 0;
++ }
++diff --git a/apps/volk_option_helpers.cc b/apps/volk_option_helpers.cc
++index 4299709..73d51da 100644
++--- a/apps/volk_option_helpers.cc
+++++ b/apps/volk_option_helpers.cc
++@@ -4,66 +4,97 @@
++
++ #include "volk_option_helpers.h"
++
++-#include <exception> // for exception
++-#include <iostream> // for operator<<, endl, basic_ostream, cout, ostream
++-#include <utility> // for pair
++-#include <limits.h> // IWYU pragma: keep
++-#include <cstring> // IWYU pragma: keep
++-#include <cstdlib> // IWYU pragma: keep
+++#include <limits.h> // IWYU pragma: keep
+++#include <cstdlib> // IWYU pragma: keep
+++#include <cstring> // IWYU pragma: keep
+++#include <exception> // for exception
+++#include <iostream> // for operator<<, endl, basic_ostream, cout, ostream
+++#include <utility> // for pair
++
++ /*
++ * Option type
++ */
++-option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)())
++- : longform("--" + longform),
++- shortform("-" + shortform),
++- msg(msg),
++- callback(callback) { option_type = VOID_CALLBACK; }
++-
++-option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(int))
++- : longform("--" + longform),
++- shortform("-" + shortform),
++- msg(msg),
++- callback((void (*)()) callback) { option_type = INT_CALLBACK; }
++-
++-option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(float))
++- : longform("--" + longform),
++- shortform("-" + shortform),
++- msg(msg),
++- callback((void (*)()) callback) { option_type = FLOAT_CALLBACK; }
++-
++-option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(bool))
++- : longform("--" + longform),
++- shortform("-" + shortform),
++- msg(msg),
++- callback((void (*)()) callback) { option_type = BOOL_CALLBACK; }
++-
++-option_t::option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(std::string))
++- : longform("--" + longform),
++- shortform("-" + shortform),
++- msg(msg),
++- callback((void (*)()) callback) { option_type = STRING_CALLBACK; }
++-
++-option_t::option_t(std::string longform, std::string shortform, std::string msg, std::string printval)
++- : longform("--" + longform),
++- shortform("-" + shortform),
++- msg(msg),
++- printval(printval) { option_type = STRING; }
+++option_t::option_t(std::string longform,
+++ std::string shortform,
+++ std::string msg,
+++ void (*callback)())
+++ : longform("--" + longform), shortform("-" + shortform), msg(msg), callback(callback)
+++{
+++ option_type = VOID_CALLBACK;
+++}
+++
+++option_t::option_t(std::string longform,
+++ std::string shortform,
+++ std::string msg,
+++ void (*callback)(int))
+++ : longform("--" + longform),
+++ shortform("-" + shortform),
+++ msg(msg),
+++ callback((void (*)())callback)
+++{
+++ option_type = INT_CALLBACK;
+++}
+++
+++option_t::option_t(std::string longform,
+++ std::string shortform,
+++ std::string msg,
+++ void (*callback)(float))
+++ : longform("--" + longform),
+++ shortform("-" + shortform),
+++ msg(msg),
+++ callback((void (*)())callback)
+++{
+++ option_type = FLOAT_CALLBACK;
+++}
+++
+++option_t::option_t(std::string longform,
+++ std::string shortform,
+++ std::string msg,
+++ void (*callback)(bool))
+++ : longform("--" + longform),
+++ shortform("-" + shortform),
+++ msg(msg),
+++ callback((void (*)())callback)
+++{
+++ option_type = BOOL_CALLBACK;
+++}
+++
+++option_t::option_t(std::string longform,
+++ std::string shortform,
+++ std::string msg,
+++ void (*callback)(std::string))
+++ : longform("--" + longform),
+++ shortform("-" + shortform),
+++ msg(msg),
+++ callback((void (*)())callback)
+++{
+++ option_type = STRING_CALLBACK;
+++}
+++
+++option_t::option_t(std::string longform,
+++ std::string shortform,
+++ std::string msg,
+++ std::string printval)
+++ : longform("--" + longform), shortform("-" + shortform), msg(msg), printval(printval)
+++{
+++ option_type = STRING;
+++}
++
++
++ /*
++ * Option List
++ */
++
++-option_list::option_list(std::string program_name) :
++- program_name(program_name) {
+++option_list::option_list(std::string program_name) : program_name(program_name)
+++{
++ internal_list = std::vector<option_t>();
++ }
++
++
++ void option_list::add(option_t opt) { internal_list.push_back(opt); }
++
++-void option_list::parse(int argc, char **argv) {
+++void option_list::parse(int argc, char** argv)
+++{
++ for (int arg_number = 0; arg_number < argc; ++arg_number) {
++ for (std::vector<option_t>::iterator this_option = internal_list.begin();
++ this_option != internal_list.end();
++@@ -73,74 +104,83 @@ void option_list::parse(int argc, char **argv) {
++ this_option->shortform == std::string(argv[arg_number])) {
++
++ if (present_options.count(this_option->longform) == 0) {
++- present_options.insert(std::pair<std::string, int>(this_option->longform, 1));
+++ present_options.insert(
+++ std::pair<std::string, int>(this_option->longform, 1));
++ } else {
++ present_options[this_option->longform] += 1;
++ }
++ switch (this_option->option_type) {
++- case VOID_CALLBACK:
++- this_option->callback();
++- break;
++- case INT_CALLBACK:
++- try {
++- int_val = atoi(argv[++arg_number]);
++- ((void (*)(int)) this_option->callback)(int_val);
++- } catch (std::exception &exc) {
++- std::cout << "An int option can only receive a number" << std::endl;
++- throw std::exception();
++- };
++- break;
++- case FLOAT_CALLBACK:
++- try {
++- double double_val = atof(argv[++arg_number]);
++- ((void (*)(float)) this_option->callback)(double_val);
++- } catch (std::exception &exc) {
++- std::cout << "A float option can only receive a number" << std::endl;
++- throw std::exception();
++- };
++- break;
++- case BOOL_CALLBACK:
++- try {
++- if (arg_number == (argc - 1)) { // this is the last arg
+++ case VOID_CALLBACK:
+++ this_option->callback();
+++ break;
+++ case INT_CALLBACK:
+++ try {
+++ int_val = atoi(argv[++arg_number]);
+++ ((void (*)(int))this_option->callback)(int_val);
+++ } catch (std::exception& exc) {
+++ std::cout << "An int option can only receive a number"
+++ << std::endl;
+++ throw std::exception();
+++ };
+++ break;
+++ case FLOAT_CALLBACK:
+++ try {
+++ double double_val = atof(argv[++arg_number]);
+++ ((void (*)(float))this_option->callback)(double_val);
+++ } catch (std::exception& exc) {
+++ std::cout << "A float option can only receive a number"
+++ << std::endl;
+++ throw std::exception();
+++ };
+++ break;
+++ case BOOL_CALLBACK:
+++ try {
+++ if (arg_number == (argc - 1)) { // this is the last arg
+++ int_val = 1;
+++ } else { // sneak a look at the next arg since it's present
+++ char* next_arg = argv[arg_number + 1];
+++ if ((strncmp(next_arg, "-", 1) == 0) ||
+++ (strncmp(next_arg, "--", 2) == 0)) {
+++ // the next arg is actually an arg, the bool is just
+++ // present, set to true
+++ int_val = 1;
+++ } else if (strncmp(next_arg, "true", 4) == 0) {
++ int_val = 1;
++- } else { // sneak a look at the next arg since it's present
++- char *next_arg = argv[arg_number + 1];
++- if ((strncmp(next_arg, "-", 1) == 0) || (strncmp(next_arg, "--", 2) == 0)) {
++- // the next arg is actually an arg, the bool is just present, set to true
++- int_val = 1;
++- } else if (strncmp(next_arg, "true", 4) == 0) {
++- int_val = 1;
++- } else if (strncmp(next_arg, "false", 5) == 0) {
++- int_val = 0;
++- } else {
++- // we got a number or a string.
++- // convert it to a number and depend on the catch to report an error condition
++- int_val = (bool) atoi(argv[++arg_number]);
++- }
+++ } else if (strncmp(next_arg, "false", 5) == 0) {
+++ int_val = 0;
+++ } else {
+++ // we got a number or a string.
+++ // convert it to a number and depend on the catch to
+++ // report an error condition
+++ int_val = (bool)atoi(argv[++arg_number]);
++ }
++- } catch (std::exception &e) {
++- int_val = INT_MIN;
++- };
++- if (int_val == INT_MIN) {
++- std::cout << "option: '" << argv[arg_number - 1] << "' -> received an unknown value. Boolean "
++- "options should receive one of '0', '1', 'true', 'false'." << std::endl;
++- throw std::exception();
++- } else if (int_val) {
++- ((void (*)(bool)) this_option->callback)(int_val);
++ }
++- break;
++- case STRING_CALLBACK:
++- try {
++- ((void (*)(std::string)) this_option->callback)(argv[++arg_number]);
++- } catch (std::exception &exc) {
++- throw std::exception();
++- };
++- case STRING:
++- std::cout << this_option->printval << std::endl;
++- break;
+++ } catch (std::exception& e) {
+++ int_val = INT_MIN;
+++ };
+++ if (int_val == INT_MIN) {
+++ std::cout
+++ << "option: '" << argv[arg_number - 1]
+++ << "' -> received an unknown value. Boolean "
+++ "options should receive one of '0', '1', 'true', 'false'."
+++ << std::endl;
+++ throw std::exception();
+++ } else if (int_val) {
+++ ((void (*)(bool))this_option->callback)(int_val);
+++ }
+++ break;
+++ case STRING_CALLBACK:
+++ try {
+++ ((void (*)(std::string))this_option->callback)(
+++ argv[++arg_number]);
+++ } catch (std::exception& exc) {
+++ throw std::exception();
+++ };
+++ case STRING:
+++ std::cout << this_option->printval << std::endl;
+++ break;
++ }
++ }
++-
++ }
++ if (std::string("--help") == std::string(argv[arg_number]) ||
++ std::string("-h") == std::string(argv[arg_number])) {
++@@ -150,7 +190,8 @@ void option_list::parse(int argc, char **argv) {
++ }
++ }
++
++-bool option_list::present(std::string option_name) {
+++bool option_list::present(std::string option_name)
+++{
++ if (present_options.count("--" + option_name)) {
++ return true;
++ } else {
++@@ -158,7 +199,8 @@ bool option_list::present(std::string option_name) {
++ }
++ }
++
++-void option_list::help() {
+++void option_list::help()
+++{
++ std::cout << program_name << std::endl;
++ std::cout << " -h [ --help ] \t\tdisplay this help message" << std::endl;
++ for (std::vector<option_t>::iterator this_option = internal_list.begin();
++@@ -172,14 +214,14 @@ void option_list::help() {
++ }
++
++ switch (help_line.size() / 8) {
++- case 0:
++- help_line += "\t";
++- case 1:
++- help_line += "\t";
++- case 2:
++- help_line += "\t";
++- case 3:
++- help_line += "\t";
+++ case 0:
+++ help_line += "\t";
+++ case 1:
+++ help_line += "\t";
+++ case 2:
+++ help_line += "\t";
+++ case 3:
+++ help_line += "\t";
++ }
++ help_line += this_option->msg;
++ std::cout << help_line << std::endl;
++diff --git a/apps/volk_option_helpers.h b/apps/volk_option_helpers.h
++index 8a71547..0756caf 100644
++--- a/apps/volk_option_helpers.h
+++++ b/apps/volk_option_helpers.h
++@@ -5,56 +5,74 @@
++ #ifndef VOLK_VOLK_OPTION_HELPERS_H
++ #define VOLK_VOLK_OPTION_HELPERS_H
++
++-#include <string>
++-#include <cstring>
++ #include <limits.h>
++-#include <vector>
+++#include <cstring>
++ #include <map>
+++#include <string>
+++#include <vector>
++
++-typedef enum
++-{
++- VOID_CALLBACK,
+++typedef enum {
+++ VOID_CALLBACK,
++ INT_CALLBACK,
++ BOOL_CALLBACK,
++ STRING_CALLBACK,
++ FLOAT_CALLBACK,
++- STRING,
+++ STRING,
++ } VOLK_OPTYPE;
++
++-class option_t {
++- public:
++- option_t(std::string longform, std::string shortform, std::string msg, void (*callback)());
++- option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(int));
++- option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(float));
++- option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(bool));
++- option_t(std::string longform, std::string shortform, std::string msg, void (*callback)(std::string));
++- option_t(std::string longform, std::string shortform, std::string msg, std::string printval);
++-
++- std::string longform;
++- std::string shortform;
++- std::string msg;
++- VOLK_OPTYPE option_type;
++- std::string printval;
++- void (*callback)();
+++class option_t
+++{
+++public:
+++ option_t(std::string longform,
+++ std::string shortform,
+++ std::string msg,
+++ void (*callback)());
+++ option_t(std::string longform,
+++ std::string shortform,
+++ std::string msg,
+++ void (*callback)(int));
+++ option_t(std::string longform,
+++ std::string shortform,
+++ std::string msg,
+++ void (*callback)(float));
+++ option_t(std::string longform,
+++ std::string shortform,
+++ std::string msg,
+++ void (*callback)(bool));
+++ option_t(std::string longform,
+++ std::string shortform,
+++ std::string msg,
+++ void (*callback)(std::string));
+++ option_t(std::string longform,
+++ std::string shortform,
+++ std::string msg,
+++ std::string printval);
++
+++ std::string longform;
+++ std::string shortform;
+++ std::string msg;
+++ VOLK_OPTYPE option_type;
+++ std::string printval;
+++ void (*callback)();
++ };
++
++ class option_list
++ {
++- public:
++- option_list(std::string program_name);
++- bool present(std::string option_name);
+++public:
+++ option_list(std::string program_name);
+++ bool present(std::string option_name);
+++
+++ void add(option_t opt);
++
++- void add(option_t opt);
+++ void parse(int argc, char** argv);
++
++- void parse(int argc, char **argv);
+++ void help();
++
++- void help();
++- private:
++- std::string program_name;
++- std::vector<option_t> internal_list;
++- std::map<std::string, int> present_options;
+++private:
+++ std::string program_name;
+++ std::vector<option_t> internal_list;
+++ std::map<std::string, int> present_options;
++ };
++
++
++-#endif //VOLK_VOLK_OPTION_HELPERS_H
+++#endif // VOLK_VOLK_OPTION_HELPERS_H
++diff --git a/apps/volk_profile.cc b/apps/volk_profile.cc
++index 4ef5aeb..3c2e324 100644
++--- a/apps/volk_profile.cc
+++++ b/apps/volk_profile.cc
++@@ -27,23 +27,23 @@
++ #include <filesystem>
++ #endif
++ #else
++-#include <boost/filesystem/operations.hpp> // for create_directories, exists
++-#include <boost/filesystem/path.hpp> // for path, operator<<
++-#include <boost/filesystem/path_traits.hpp> // for filesystem
+++#include <boost/filesystem/operations.hpp> // for create_directories, exists
+++#include <boost/filesystem/path.hpp> // for path, operator<<
+++#include <boost/filesystem/path_traits.hpp> // for filesystem
++ #endif
++-#include <stddef.h> // for size_t
++-#include <sys/stat.h> // for stat
++-#include <volk/volk_prefs.h> // for volk_get_config_path
++-#include <iostream> // for operator<<, basic_ostream
++-#include <fstream> // IWYU pragma: keep
++-#include <map> // for map, map<>::iterator
++-#include <utility> // for pair
++-#include <vector> // for vector, vector<>::const_...
++-
++-#include "kernel_tests.h" // for init_test_list
++-#include "qa_utils.h" // for volk_test_results_t, vol...
++-#include "volk/volk_complex.h" // for lv_32fc_t
++-#include "volk_option_helpers.h" // for option_list, option_t
+++#include <stddef.h> // for size_t
+++#include <sys/stat.h> // for stat
+++#include <volk/volk_prefs.h> // for volk_get_config_path
+++#include <fstream> // IWYU pragma: keep
+++#include <iostream> // for operator<<, basic_ostream
+++#include <map> // for map, map<>::iterator
+++#include <utility> // for pair
+++#include <vector> // for vector, vector<>::const_...
+++
+++#include "kernel_tests.h" // for init_test_list
+++#include "qa_utils.h" // for volk_test_results_t, vol...
+++#include "volk/volk_complex.h" // for lv_32fc_t
+++#include "volk_option_helpers.h" // for option_list, option_t
++ #include "volk_profile.h"
++
++ #if HAS_STD_FILESYSTEM
++@@ -72,45 +72,61 @@ void set_json(std::string val) { json_filename = val; }
++ std::string volk_config_path("");
++ void set_volk_config(std::string val) { volk_config_path = val; }
++
++-int main(int argc, char *argv[]) {
+++int main(int argc, char* argv[])
+++{
++
++ option_list profile_options("volk_profile");
++- profile_options.add(option_t("benchmark", "b", "Run all kernels (benchmark mode)", set_benchmark));
++- profile_options.add(option_t("tol", "t", "Set the default tolerance for all tests", set_tolerance));
++- profile_options.add(option_t("vlen", "v", "Set the default vector length for tests", set_vlen));
++- profile_options.add((option_t("iter", "i", "Set the default number of test iterations per kernel", set_iter)));
++- profile_options.add((option_t("tests-substr", "R", "Run tests matching substring", set_substr)));
++- profile_options.add((option_t("update", "u", "Run only kernels missing from config", set_update)));
++- profile_options.add((option_t("dry-run", "n", "Dry run. Respect other options, but don't write to file", set_dryrun)));
++- profile_options.add((option_t("json", "j", "Write results to JSON file named as argument value", set_json)));
++- profile_options.add((option_t("path", "p", "Specify the volk_config path", set_volk_config)));
+++ profile_options.add(
+++ option_t("benchmark", "b", "Run all kernels (benchmark mode)", set_benchmark));
+++ profile_options.add(
+++ option_t("tol", "t", "Set the default tolerance for all tests", set_tolerance));
+++ profile_options.add(
+++ option_t("vlen", "v", "Set the default vector length for tests", set_vlen));
+++ profile_options.add((option_t(
+++ "iter", "i", "Set the default number of test iterations per kernel", set_iter)));
+++ profile_options.add(
+++ (option_t("tests-substr", "R", "Run tests matching substring", set_substr)));
+++ profile_options.add(
+++ (option_t("update", "u", "Run only kernels missing from config", set_update)));
+++ profile_options.add(
+++ (option_t("dry-run",
+++ "n",
+++ "Dry run. Respect other options, but don't write to file",
+++ set_dryrun)));
+++ profile_options.add((option_t(
+++ "json", "j", "Write results to JSON file named as argument value", set_json)));
+++ profile_options.add(
+++ (option_t("path", "p", "Specify the volk_config path", set_volk_config)));
++ profile_options.parse(argc, argv);
++
++ if (profile_options.present("help")) {
++ return 0;
++ }
++
++- if(dry_run) {
++- std::cout << "Warning: this IS a dry-run. Config will not be written!" << std::endl;
+++ if (dry_run) {
+++ std::cout << "Warning: this IS a dry-run. Config will not be written!"
+++ << std::endl;
++ }
++
++ // Adding program options
++ std::ofstream json_file;
++ std::string config_file;
++
++- if ( json_filename != "" ) {
++- json_file.open( json_filename.c_str() );
+++ if (json_filename != "") {
+++ json_file.open(json_filename.c_str());
++ }
++
++- if ( volk_config_path != "" ) {
+++ if (volk_config_path != "") {
++ config_file = volk_config_path + "/volk_config";
++ }
++
++ // Run tests
++ std::vector<volk_test_results_t> results;
++- if(update_mode) {
++- if( config_file != "" ) read_results(&results, config_file);
++- else read_results(&results);
+++ if (update_mode) {
+++ if (config_file != "")
+++ read_results(&results, config_file);
+++ else
+++ read_results(&results);
++ }
++
++ // Initialize the list of tests
++@@ -118,22 +134,22 @@ int main(int argc, char *argv[]) {
++
++ // Iterate through list of tests running each one
++ std::string substr_to_match(test_params.kernel_regex());
++- for(unsigned int ii = 0; ii < test_cases.size(); ++ii) {
+++ for (unsigned int ii = 0; ii < test_cases.size(); ++ii) {
++ bool regex_match = true;
++
++ volk_test_case_t test_case = test_cases[ii];
++ // if the kernel name matches regex then do the test
++ std::string test_case_name = test_case.name();
++- if(test_case_name.find(substr_to_match) == std::string::npos) {
+++ if (test_case_name.find(substr_to_match) == std::string::npos) {
++ regex_match = false;
++ }
++
++ // if we are in update mode check if we've already got results
++ // if we have any, then no need to test that kernel
++ bool update = true;
++- if(update_mode) {
++- for(unsigned int jj=0; jj < results.size(); ++jj) {
++- if(results[jj].name == test_case.name() ||
+++ if (update_mode) {
+++ for (unsigned int jj = 0; jj < results.size(); ++jj) {
+++ if (results[jj].name == test_case.name() ||
++ results[jj].name == test_case.puppet_master_name()) {
++ update = false;
++ break;
++@@ -141,39 +157,44 @@ int main(int argc, char *argv[]) {
++ }
++ }
++
++- if( regex_match && update ) {
+++ if (regex_match && update) {
++ try {
++- run_volk_tests(test_case.desc(), test_case.kernel_ptr(), test_case.name(),
++- test_case.test_parameters(), &results, test_case.puppet_master_name());
++- }
++- catch (std::string &error) {
++- std::cerr << "Caught Exception in 'run_volk_tests': " << error << std::endl;
+++ run_volk_tests(test_case.desc(),
+++ test_case.kernel_ptr(),
+++ test_case.name(),
+++ test_case.test_parameters(),
+++ &results,
+++ test_case.puppet_master_name());
+++ } catch (std::string& error) {
+++ std::cerr << "Caught Exception in 'run_volk_tests': " << error
+++ << std::endl;
++ }
++ }
++ }
++
++
++ // Output results according to provided options
++- if(json_filename != "") {
+++ if (json_filename != "") {
++ write_json(json_file, results);
++ json_file.close();
++ }
++
++- if(!dry_run) {
++- if(config_file != "") write_results(&results, false, config_file);
++- else write_results(&results, false);
++- }
++- else {
+++ if (!dry_run) {
+++ if (config_file != "")
+++ write_results(&results, false, config_file);
+++ else
+++ write_results(&results, false);
+++ } else {
++ std::cout << "Warning: this was a dry-run. Config not generated" << std::endl;
++ }
++ return 0;
++ }
++
++-void read_results(std::vector<volk_test_results_t> *results)
+++void read_results(std::vector<volk_test_results_t>* results)
++ {
++ char path[1024];
++ volk_get_config_path(path, true);
++- if(path[0] == 0){
+++ if (path[0] == 0) {
++ std::cout << "No prior test results found ..." << std::endl;
++ return;
++ }
++@@ -181,16 +202,16 @@ void read_results(std::vector<volk_test_results_t> *results)
++ read_results(results, std::string(path));
++ }
++
++-void read_results(std::vector<volk_test_results_t> *results, std::string path)
+++void read_results(std::vector<volk_test_results_t>* results, std::string path)
++ {
++ struct stat buffer;
++- bool config_status = (stat (path.c_str(), &buffer) == 0);
+++ bool config_status = (stat(path.c_str(), &buffer) == 0);
++
++- if( config_status ) {
+++ if (config_status) {
++ // a config exists and we are reading results from it
++ std::ifstream config(path.c_str());
++ char config_line[256];
++- while(config.getline(config_line, 255)) {
+++ while (config.getline(config_line, 255)) {
++ // tokenize the input line by kernel_name unaligned aligned
++ // then push back in the results vector with fields filled in
++
++@@ -198,26 +219,26 @@ void read_results(std::vector<volk_test_results_t> *results, std::string path)
++ std::string config_str(config_line);
++ std::size_t str_size = config_str.size();
++ std::size_t found = config_str.find(' ');
++-
+++
++ // Split line by spaces
++- while(found && found < str_size) {
+++ while (found && found < str_size) {
++ found = config_str.find(' ');
++ // kernel names MUST be less than 128 chars, which is
++ // a length restricted by volk/volk_prefs.c
++ // on the last token in the parsed string we won't find a space
++ // so make sure we copy at most 128 chars.
++- if(found > 127) {
+++ if (found > 127) {
++ found = 127;
++ }
++ str_size = config_str.size();
++- char buffer[128] = {'\0'};
+++ char buffer[128] = { '\0' };
++ config_str.copy(buffer, found + 1, 0);
++ buffer[found] = '\0';
++ single_kernel_result.push_back(std::string(buffer));
++- config_str.erase(0, found+1);
+++ config_str.erase(0, found + 1);
++ }
++
++- if(single_kernel_result.size() == 3) {
+++ if (single_kernel_result.size() == 3) {
++ volk_test_results_t kernel_result;
++ kernel_result.name = std::string(single_kernel_result[0]);
++ kernel_result.config_name = std::string(single_kernel_result[0]);
++@@ -229,45 +250,47 @@ void read_results(std::vector<volk_test_results_t> *results, std::string path)
++ }
++ }
++
++-void write_results(const std::vector<volk_test_results_t> *results, bool update_result)
+++void write_results(const std::vector<volk_test_results_t>* results, bool update_result)
++ {
++ char path[1024];
++ volk_get_config_path(path, false);
++- if(path[0] == 0){
+++ if (path[0] == 0) {
++ std::cout << "Aborting 'No config save path found' ..." << std::endl;
++ return;
++ }
++
++- write_results( results, update_result, std::string(path));
+++ write_results(results, update_result, std::string(path));
++ }
++
++-void write_results(const std::vector<volk_test_results_t> *results, bool update_result, const std::string path)
+++void write_results(const std::vector<volk_test_results_t>* results,
+++ bool update_result,
+++ const std::string path)
++ {
++-// struct stat buffer;
++-// bool config_status = (stat (path.c_str(), &buffer) == 0);
+++ // struct stat buffer;
+++ // bool config_status = (stat (path.c_str(), &buffer) == 0);
++
++ /*
++ * These
++ */
++ const fs::path config_path(path);
++- if (! fs::exists(config_path.parent_path()))
++- {
+++ if (!fs::exists(config_path.parent_path())) {
++ std::cout << "Creating " << config_path.parent_path() << "..." << std::endl;
++ fs::create_directories(config_path.parent_path());
++ }
++
++ std::ofstream config;
++- if(update_result) {
+++ if (update_result) {
++ std::cout << "Updating " << path << "..." << std::endl;
++ config.open(path.c_str(), std::ofstream::app);
++- if (!config.is_open()) { //either we don't have write access or we don't have the dir yet
+++ if (!config.is_open()) { // either we don't have write access or we don't have the
+++ // dir yet
++ std::cout << "Error opening file " << path << std::endl;
++ }
++- }
++- else {
+++ } else {
++ std::cout << "Writing " << path << "..." << std::endl;
++ config.open(path.c_str());
++- if (!config.is_open()) { //either we don't have write access or we don't have the dir yet
+++ if (!config.is_open()) { // either we don't have write access or we don't have the
+++ // dir yet
++ std::cout << "Error opening file " << path << std::endl;
++ }
++
++@@ -278,43 +301,45 @@ void write_results(const std::vector<volk_test_results_t> *results, bool update_
++ }
++
++ std::vector<volk_test_results_t>::const_iterator profile_results;
++- for(profile_results = results->begin(); profile_results != results->end(); ++profile_results) {
++- config << profile_results->config_name << " "
++- << profile_results->best_arch_a << " "
++- << profile_results->best_arch_u << std::endl;
+++ for (profile_results = results->begin(); profile_results != results->end();
+++ ++profile_results) {
+++ config << profile_results->config_name << " " << profile_results->best_arch_a
+++ << " " << profile_results->best_arch_u << std::endl;
++ }
++ config.close();
++ }
++
++-void write_json(std::ofstream &json_file, std::vector<volk_test_results_t> results)
+++void write_json(std::ofstream& json_file, std::vector<volk_test_results_t> results)
++ {
++ json_file << "{" << std::endl;
++ json_file << " \"volk_tests\": [" << std::endl;
++ size_t len = results.size();
++ size_t i = 0;
++ std::vector<volk_test_results_t>::iterator result;
++- for(result = results.begin(); result != results.end(); ++result) {
+++ for (result = results.begin(); result != results.end(); ++result) {
++ json_file << " {" << std::endl;
++ json_file << " \"name\": \"" << result->name << "\"," << std::endl;
++ json_file << " \"vlen\": " << (int)(result->vlen) << "," << std::endl;
++ json_file << " \"iter\": " << result->iter << "," << std::endl;
++- json_file << " \"best_arch_a\": \"" << result->best_arch_a
++- << "\"," << std::endl;
++- json_file << " \"best_arch_u\": \"" << result->best_arch_u
++- << "\"," << std::endl;
+++ json_file << " \"best_arch_a\": \"" << result->best_arch_a << "\","
+++ << std::endl;
+++ json_file << " \"best_arch_u\": \"" << result->best_arch_u << "\","
+++ << std::endl;
++ json_file << " \"results\": {" << std::endl;
++ size_t results_len = result->results.size();
++ size_t ri = 0;
++
++ std::map<std::string, volk_test_time_t>::iterator kernel_time_pair;
++- for(kernel_time_pair = result->results.begin(); kernel_time_pair != result->results.end(); ++kernel_time_pair) {
+++ for (kernel_time_pair = result->results.begin();
+++ kernel_time_pair != result->results.end();
+++ ++kernel_time_pair) {
++ volk_test_time_t time = kernel_time_pair->second;
++ json_file << " \"" << time.name << "\": {" << std::endl;
++ json_file << " \"name\": \"" << time.name << "\"," << std::endl;
++ json_file << " \"time\": " << time.time << "," << std::endl;
++ json_file << " \"units\": \"" << time.units << "\"" << std::endl;
++- json_file << " }" ;
++- if(ri+1 != results_len) {
+++ json_file << " }";
+++ if (ri + 1 != results_len) {
++ json_file << ",";
++ }
++ json_file << std::endl;
++@@ -322,7 +347,7 @@ void write_json(std::ofstream &json_file, std::vector<volk_test_results_t> resul
++ }
++ json_file << " }" << std::endl;
++ json_file << " }";
++- if(i+1 != len) {
+++ if (i + 1 != len) {
++ json_file << ",";
++ }
++ json_file << std::endl;
++diff --git a/apps/volk_profile.h b/apps/volk_profile.h
++index 51629ab..ae3b474 100644
++--- a/apps/volk_profile.h
+++++ b/apps/volk_profile.h
++@@ -1,14 +1,16 @@
++
++
++-#include <stdbool.h> // for bool
++-#include <iosfwd> // for ofstream
++-#include <string> // for string
++-#include <vector> // for vector
+++#include <stdbool.h> // for bool
+++#include <iosfwd> // for ofstream
+++#include <string> // for string
+++#include <vector> // for vector
++
++ class volk_test_results_t;
++
++-void read_results(std::vector<volk_test_results_t> *results);
++-void read_results(std::vector<volk_test_results_t> *results, std::string path);
++-void write_results(const std::vector<volk_test_results_t> *results, bool update_result);
++-void write_results(const std::vector<volk_test_results_t> *results, bool update_result, const std::string path);
++-void write_json(std::ofstream &json_file, std::vector<volk_test_results_t> results);
+++void read_results(std::vector<volk_test_results_t>* results);
+++void read_results(std::vector<volk_test_results_t>* results, std::string path);
+++void write_results(const std::vector<volk_test_results_t>* results, bool update_result);
+++void write_results(const std::vector<volk_test_results_t>* results,
+++ bool update_result,
+++ const std::string path);
+++void write_json(std::ofstream& json_file, std::vector<volk_test_results_t> results);
++diff --git a/cmake/msvc/config.h b/cmake/msvc/config.h
++index 8b12c2a..68f716e 100644
++--- a/cmake/msvc/config.h
+++++ b/cmake/msvc/config.h
++@@ -9,7 +9,7 @@
++ // enable inline functions for C code
++ ////////////////////////////////////////////////////////////////////////
++ #ifndef __cplusplus
++-# define inline __inline
+++#define inline __inline
++ #endif
++
++ ////////////////////////////////////////////////////////////////////////
++@@ -23,12 +23,21 @@ typedef ptrdiff_t ssize_t;
++ ////////////////////////////////////////////////////////////////////////
++ #if _MSC_VER < 1800
++ #include <math.h>
++-static inline long lrint(double x){return (long)(x > 0.0 ? x + 0.5 : x - 0.5);}
++-static inline long lrintf(float x){return (long)(x > 0.0f ? x + 0.5f : x - 0.5f);}
++-static inline long long llrint(double x){return (long long)(x > 0.0 ? x + 0.5 : x - 0.5);}
++-static inline long long llrintf(float x){return (long long)(x > 0.0f ? x + 0.5f : x - 0.5f);}
++-static inline double rint(double x){return (x > 0.0)? floor(x + 0.5) : ceil(x - 0.5);}
++-static inline float rintf(float x){return (x > 0.0f)? floorf(x + 0.5f) : ceilf(x - 0.5f);}
+++static inline long lrint(double x) { return (long)(x > 0.0 ? x + 0.5 : x - 0.5); }
+++static inline long lrintf(float x) { return (long)(x > 0.0f ? x + 0.5f : x - 0.5f); }
+++static inline long long llrint(double x)
+++{
+++ return (long long)(x > 0.0 ? x + 0.5 : x - 0.5);
+++}
+++static inline long long llrintf(float x)
+++{
+++ return (long long)(x > 0.0f ? x + 0.5f : x - 0.5f);
+++}
+++static inline double rint(double x) { return (x > 0.0) ? floor(x + 0.5) : ceil(x - 0.5); }
+++static inline float rintf(float x)
+++{
+++ return (x > 0.0f) ? floorf(x + 0.5f) : ceilf(x - 0.5f);
+++}
++ #endif
++
++ ////////////////////////////////////////////////////////////////////////
++@@ -43,7 +52,7 @@ static inline float rintf(float x){return (x > 0.0f)? floorf(x + 0.5f) : ceilf(x
++ // random and srandom
++ ////////////////////////////////////////////////////////////////////////
++ #include <stdlib.h>
++-static inline long int random (void) { return rand(); }
++-static inline void srandom (unsigned int seed) { srand(seed); }
+++static inline long int random(void) { return rand(); }
+++static inline void srandom(unsigned int seed) { srand(seed); }
++
++ #endif // _MSC_CONFIG_H_ ]
++diff --git a/cmake/msvc/sys/time.h b/cmake/msvc/sys/time.h
++index aa0f5dc..4bda1ba 100644
++--- a/cmake/msvc/sys/time.h
+++++ b/cmake/msvc/sys/time.h
++@@ -10,67 +10,62 @@
++ #define NOMINMAX
++ #endif
++
++-//http://social.msdn.microsoft.com/Forums/en/vcgeneral/thread/430449b3-f6dd-4e18-84de-eebd26a8d668
+++// http://social.msdn.microsoft.com/Forums/en/vcgeneral/thread/430449b3-f6dd-4e18-84de-eebd26a8d668
++ #include < time.h >
++ #include <windows.h> //I've omitted this line.
++ #if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
++- #define DELTA_EPOCH_IN_MICROSECS 11644473600000000Ui64
+++#define DELTA_EPOCH_IN_MICROSECS 11644473600000000Ui64
++ #else
++- #define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
+++#define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
++ #endif
++
++ #if _MSC_VER < 1900
++ struct timespec {
++
++-time_t tv_sec; /* Seconds since 00:00:00 GMT, */
+++ time_t tv_sec; /* Seconds since 00:00:00 GMT, */
++
++-/* 1 January 1970 */
+++ /* 1 January 1970 */
++
++-long tv_nsec; /* Additional nanoseconds since */
++-
++-/* tv_sec */
+++ long tv_nsec; /* Additional nanoseconds since */
++
+++ /* tv_sec */
++ };
++ #endif
++
++-struct timezone
++-{
++- int tz_minuteswest; /* minutes W of Greenwich */
++- int tz_dsttime; /* type of dst correction */
+++struct timezone {
+++ int tz_minuteswest; /* minutes W of Greenwich */
+++ int tz_dsttime; /* type of dst correction */
++ };
++
++-static inline int gettimeofday(struct timeval *tv, struct timezone *tz)
+++static inline int gettimeofday(struct timeval* tv, struct timezone* tz)
++ {
++- FILETIME ft;
++- unsigned __int64 tmpres = 0;
++- static int tzflag;
++-
++- if (NULL != tv)
++- {
++- GetSystemTimeAsFileTime(&ft);
++-
++- tmpres |= ft.dwHighDateTime;
++- tmpres <<= 32;
++- tmpres |= ft.dwLowDateTime;
++-
++- /*converting file time to unix epoch*/
++- tmpres -= DELTA_EPOCH_IN_MICROSECS;
++- tv->tv_sec = (long)(tmpres / 1000000UL);
++- tv->tv_usec = (long)(tmpres % 1000000UL);
++- }
++-
++- if (NULL != tz)
++- {
++- if (!tzflag)
++- {
++- _tzset();
++- tzflag++;
+++ FILETIME ft;
+++ unsigned __int64 tmpres = 0;
+++ static int tzflag;
+++
+++ if (NULL != tv) {
+++ GetSystemTimeAsFileTime(&ft);
+++
+++ tmpres |= ft.dwHighDateTime;
+++ tmpres <<= 32;
+++ tmpres |= ft.dwLowDateTime;
+++
+++ /*converting file time to unix epoch*/
+++ tmpres -= DELTA_EPOCH_IN_MICROSECS;
+++ tv->tv_sec = (long)(tmpres / 1000000UL);
+++ tv->tv_usec = (long)(tmpres % 1000000UL);
+++ }
+++
+++ if (NULL != tz) {
+++ if (!tzflag) {
+++ _tzset();
+++ tzflag++;
+++ }
+++ tz->tz_minuteswest = _timezone / 60;
+++ tz->tz_dsttime = _daylight;
++ }
++- tz->tz_minuteswest = _timezone / 60;
++- tz->tz_dsttime = _daylight;
++- }
++
++- return 0;
+++ return 0;
++ }
++
++ #endif //_MSC_SYS_TIME_H_
++diff --git a/include/volk/saturation_arithmetic.h b/include/volk/saturation_arithmetic.h
++index 0886844..7b95ba2 100644
++--- a/include/volk/saturation_arithmetic.h
+++++ b/include/volk/saturation_arithmetic.h
++@@ -28,20 +28,24 @@
++
++ static inline int16_t sat_adds16i(int16_t x, int16_t y)
++ {
++- int32_t res = (int32_t) x + (int32_t) y;
+++ int32_t res = (int32_t)x + (int32_t)y;
++
++- if (res < SHRT_MIN) res = SHRT_MIN;
++- if (res > SHRT_MAX) res = SHRT_MAX;
+++ if (res < SHRT_MIN)
+++ res = SHRT_MIN;
+++ if (res > SHRT_MAX)
+++ res = SHRT_MAX;
++
++ return res;
++ }
++
++ static inline int16_t sat_muls16i(int16_t x, int16_t y)
++ {
++- int32_t res = (int32_t) x * (int32_t) y;
+++ int32_t res = (int32_t)x * (int32_t)y;
++
++- if (res < SHRT_MIN) res = SHRT_MIN;
++- if (res > SHRT_MAX) res = SHRT_MAX;
+++ if (res < SHRT_MIN)
+++ res = SHRT_MIN;
+++ if (res > SHRT_MAX)
+++ res = SHRT_MAX;
++
++ return res;
++ }
++diff --git a/include/volk/volk_alloc.hh b/include/volk/volk_alloc.hh
++index a2975da..44bcfaf 100644
++--- a/include/volk/volk_alloc.hh
+++++ b/include/volk/volk_alloc.hh
++@@ -40,30 +40,40 @@ namespace volk {
++ */
++ template <class T>
++ struct alloc {
++- typedef T value_type;
+++ typedef T value_type;
++
++- alloc() = default;
+++ alloc() = default;
++
++- template <class U> constexpr alloc(alloc<U> const&) noexcept {}
+++ template <class U>
+++ constexpr alloc(alloc<U> const&) noexcept
+++ {
+++ }
++
++- T* allocate(std::size_t n) {
++- if (n > std::numeric_limits<std::size_t>::max() / sizeof(T)) throw std::bad_alloc();
+++ T* allocate(std::size_t n)
+++ {
+++ if (n > std::numeric_limits<std::size_t>::max() / sizeof(T))
+++ throw std::bad_alloc();
++
++- if (auto p = static_cast<T*>(volk_malloc(n*sizeof(T), volk_get_alignment())))
++- return p;
+++ if (auto p = static_cast<T*>(volk_malloc(n * sizeof(T), volk_get_alignment())))
+++ return p;
++
++- throw std::bad_alloc();
++- }
+++ throw std::bad_alloc();
+++ }
++
++- void deallocate(T* p, std::size_t) noexcept { volk_free(p); }
++-
++-} ;
+++ void deallocate(T* p, std::size_t) noexcept { volk_free(p); }
+++};
++
++ template <class T, class U>
++-bool operator==(alloc<T> const&, alloc<U> const&) { return true; }
+++bool operator==(alloc<T> const&, alloc<U> const&)
+++{
+++ return true;
+++}
++
++ template <class T, class U>
++-bool operator!=(alloc<T> const&, alloc<U> const&) { return false; }
+++bool operator!=(alloc<T> const&, alloc<U> const&)
+++{
+++ return false;
+++}
++
++
++ /*!
++@@ -73,8 +83,8 @@ bool operator!=(alloc<T> const&, alloc<U> const&) { return false; }
++ * example code:
++ * volk::vector<float> v(100); // vector using volk_malloc, volk_free
++ */
++-template<class T>
++-using vector = std::vector<T, alloc<T> >;
+++template <class T>
+++using vector = std::vector<T, alloc<T>>;
++
++ } // namespace volk
++ #endif // INCLUDED_VOLK_ALLOC_H
++diff --git a/include/volk/volk_avx2_intrinsics.h b/include/volk/volk_avx2_intrinsics.h
++index 17badc4..00f3b52 100644
++--- a/include/volk/volk_avx2_intrinsics.h
+++++ b/include/volk/volk_avx2_intrinsics.h
++@@ -1,19 +1,19 @@
++ /* -*- c++ -*- */
++-/*
+++/*
++ * Copyright 2015 Free Software Foundation, Inc.
++- *
+++ *
++ * This file is part of GNU Radio
++- *
+++ *
++ * GNU Radio is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 3, or (at your option)
++ * any later version.
++- *
+++ *
++ * GNU Radio is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++- *
+++ *
++ * You should have received a copy of the GNU General Public License
++ * along with GNU Radio; see the file COPYING. If not, write to
++ * the Free Software Foundation, Inc., 51 Franklin Street,
++@@ -27,28 +27,59 @@
++
++ #ifndef INCLUDE_VOLK_VOLK_AVX2_INTRINSICS_H_
++ #define INCLUDE_VOLK_VOLK_AVX2_INTRINSICS_H_
++-#include <immintrin.h>
++ #include "volk/volk_avx_intrinsics.h"
+++#include <immintrin.h>
++
++-static inline __m256
++-_mm256_polar_sign_mask_avx2(__m128i fbits){
++- const __m128i zeros = _mm_set1_epi8(0x00);
++- const __m128i sign_extract = _mm_set1_epi8(0x80);
++- const __m256i shuffle_mask = _mm256_setr_epi8(0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x02, 0xff, 0xff, 0xff, 0x03,
++- 0xff, 0xff, 0xff, 0x04, 0xff, 0xff, 0xff, 0x05, 0xff, 0xff, 0xff, 0x06, 0xff, 0xff, 0xff, 0x07);
++- __m256i sign_bits = _mm256_setzero_si256();
++-
++- fbits = _mm_cmpgt_epi8(fbits, zeros);
++- fbits = _mm_and_si128(fbits, sign_extract);
++- sign_bits = _mm256_insertf128_si256(sign_bits,fbits,0);
++- sign_bits = _mm256_insertf128_si256(sign_bits,fbits,1);
++- sign_bits = _mm256_shuffle_epi8(sign_bits, shuffle_mask);
+++static inline __m256 _mm256_polar_sign_mask_avx2(__m128i fbits)
+++{
+++ const __m128i zeros = _mm_set1_epi8(0x00);
+++ const __m128i sign_extract = _mm_set1_epi8(0x80);
+++ const __m256i shuffle_mask = _mm256_setr_epi8(0xff,
+++ 0xff,
+++ 0xff,
+++ 0x00,
+++ 0xff,
+++ 0xff,
+++ 0xff,
+++ 0x01,
+++ 0xff,
+++ 0xff,
+++ 0xff,
+++ 0x02,
+++ 0xff,
+++ 0xff,
+++ 0xff,
+++ 0x03,
+++ 0xff,
+++ 0xff,
+++ 0xff,
+++ 0x04,
+++ 0xff,
+++ 0xff,
+++ 0xff,
+++ 0x05,
+++ 0xff,
+++ 0xff,
+++ 0xff,
+++ 0x06,
+++ 0xff,
+++ 0xff,
+++ 0xff,
+++ 0x07);
+++ __m256i sign_bits = _mm256_setzero_si256();
++
++- return _mm256_castsi256_ps(sign_bits);
+++ fbits = _mm_cmpgt_epi8(fbits, zeros);
+++ fbits = _mm_and_si128(fbits, sign_extract);
+++ sign_bits = _mm256_insertf128_si256(sign_bits, fbits, 0);
+++ sign_bits = _mm256_insertf128_si256(sign_bits, fbits, 1);
+++ sign_bits = _mm256_shuffle_epi8(sign_bits, shuffle_mask);
+++
+++ return _mm256_castsi256_ps(sign_bits);
++ }
++
++ static inline __m256
++-_mm256_polar_fsign_add_llrs_avx2(__m256 src0, __m256 src1, __m128i fbits){
+++_mm256_polar_fsign_add_llrs_avx2(__m256 src0, __m256 src1, __m128i fbits)
+++{
++ // prepare sign mask for correct +-
++ __m256 sign_mask = _mm256_polar_sign_mask_avx2(fbits);
++
++@@ -61,26 +92,31 @@ _mm256_polar_fsign_add_llrs_avx2(__m256 src0, __m256 src1, __m128i fbits){
++ return dst;
++ }
++
++-static inline __m256
++-_mm256_magnitudesquared_ps_avx2(const __m256 cplxValue0, const __m256 cplxValue1){
++- const __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
++- const __m256 squared0 = _mm256_mul_ps(cplxValue0, cplxValue0); // Square the values
++- const __m256 squared1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the Values
++- const __m256 complex_result = _mm256_hadd_ps(squared0, squared1);
++- return _mm256_permutevar8x32_ps(complex_result, idx);
+++static inline __m256 _mm256_magnitudesquared_ps_avx2(const __m256 cplxValue0,
+++ const __m256 cplxValue1)
+++{
+++ const __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
+++ const __m256 squared0 = _mm256_mul_ps(cplxValue0, cplxValue0); // Square the values
+++ const __m256 squared1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the Values
+++ const __m256 complex_result = _mm256_hadd_ps(squared0, squared1);
+++ return _mm256_permutevar8x32_ps(complex_result, idx);
++ }
++
++-static inline __m256
++-_mm256_scaled_norm_dist_ps_avx2(const __m256 symbols0, const __m256 symbols1, const __m256 points0, const __m256 points1, const __m256 scalar){
++- /*
++- * Calculate: |y - x|^2 * SNR_lin
++- * Consider 'symbolsX' and 'pointsX' to be complex float
++- * 'symbolsX' are 'y' and 'pointsX' are 'x'
++- */
++- const __m256 diff0 = _mm256_sub_ps(symbols0, points0);
++- const __m256 diff1 = _mm256_sub_ps(symbols1, points1);
++- const __m256 norms = _mm256_magnitudesquared_ps_avx2(diff0, diff1);
++- return _mm256_mul_ps(norms, scalar);
+++static inline __m256 _mm256_scaled_norm_dist_ps_avx2(const __m256 symbols0,
+++ const __m256 symbols1,
+++ const __m256 points0,
+++ const __m256 points1,
+++ const __m256 scalar)
+++{
+++ /*
+++ * Calculate: |y - x|^2 * SNR_lin
+++ * Consider 'symbolsX' and 'pointsX' to be complex float
+++ * 'symbolsX' are 'y' and 'pointsX' are 'x'
+++ */
+++ const __m256 diff0 = _mm256_sub_ps(symbols0, points0);
+++ const __m256 diff1 = _mm256_sub_ps(symbols1, points1);
+++ const __m256 norms = _mm256_magnitudesquared_ps_avx2(diff0, diff1);
+++ return _mm256_mul_ps(norms, scalar);
++ }
++
++ #endif /* INCLUDE_VOLK_VOLK_AVX2_INTRINSICS_H_ */
++diff --git a/include/volk/volk_avx_intrinsics.h b/include/volk/volk_avx_intrinsics.h
++index 808799f..bec846d 100644
++--- a/include/volk/volk_avx_intrinsics.h
+++++ b/include/volk/volk_avx_intrinsics.h
++@@ -1,19 +1,19 @@
++ /* -*- c++ -*- */
++-/*
+++/*
++ * Copyright 2015 Free Software Foundation, Inc.
++- *
+++ *
++ * This file is part of GNU Radio
++- *
+++ *
++ * GNU Radio is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 3, or (at your option)
++ * any later version.
++- *
+++ *
++ * GNU Radio is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++- *
+++ *
++ * You should have received a copy of the GNU General Public License
++ * along with GNU Radio; see the file COPYING. If not, write to
++ * the Free Software Foundation, Inc., 51 Franklin Street,
++@@ -29,90 +29,126 @@
++ #define INCLUDE_VOLK_VOLK_AVX_INTRINSICS_H_
++ #include <immintrin.h>
++
++-static inline __m256
++-_mm256_complexmul_ps(__m256 x, __m256 y)
+++static inline __m256 _mm256_complexmul_ps(__m256 x, __m256 y)
++ {
++- __m256 yl, yh, tmp1, tmp2;
++- yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr ...
++- yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di ...
++- tmp1 = _mm256_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr ...
++- x = _mm256_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br ...
++- tmp2 = _mm256_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
++- return _mm256_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ __m256 yl, yh, tmp1, tmp2;
+++ yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr ...
+++ yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di ...
+++ tmp1 = _mm256_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr ...
+++ x = _mm256_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br ...
+++ tmp2 = _mm256_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+++ return _mm256_addsub_ps(tmp1,
+++ tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++ }
++
++-static inline __m256
++-_mm256_conjugate_ps(__m256 x){
++- const __m256 conjugator = _mm256_setr_ps(0, -0.f, 0, -0.f, 0, -0.f, 0, -0.f);
++- return _mm256_xor_ps(x, conjugator); // conjugate y
+++static inline __m256 _mm256_conjugate_ps(__m256 x)
+++{
+++ const __m256 conjugator = _mm256_setr_ps(0, -0.f, 0, -0.f, 0, -0.f, 0, -0.f);
+++ return _mm256_xor_ps(x, conjugator); // conjugate y
++ }
++
++-static inline __m256
++-_mm256_complexconjugatemul_ps(__m256 x, __m256 y){
++- y = _mm256_conjugate_ps(y);
++- return _mm256_complexmul_ps(x, y);
+++static inline __m256 _mm256_complexconjugatemul_ps(__m256 x, __m256 y)
+++{
+++ y = _mm256_conjugate_ps(y);
+++ return _mm256_complexmul_ps(x, y);
++ }
++
++-static inline __m256
++-_mm256_normalize_ps(__m256 val)
+++static inline __m256 _mm256_normalize_ps(__m256 val)
++ {
++- __m256 tmp1 = _mm256_mul_ps(val, val);
++- tmp1 = _mm256_hadd_ps(tmp1, tmp1);
++- tmp1 = _mm256_shuffle_ps(tmp1, tmp1, _MM_SHUFFLE(3, 1, 2, 0)); // equals 0xD8
++- tmp1 = _mm256_sqrt_ps(tmp1);
++- return _mm256_div_ps(val, tmp1);
+++ __m256 tmp1 = _mm256_mul_ps(val, val);
+++ tmp1 = _mm256_hadd_ps(tmp1, tmp1);
+++ tmp1 = _mm256_shuffle_ps(tmp1, tmp1, _MM_SHUFFLE(3, 1, 2, 0)); // equals 0xD8
+++ tmp1 = _mm256_sqrt_ps(tmp1);
+++ return _mm256_div_ps(val, tmp1);
++ }
++
++-static inline __m256
++-_mm256_magnitudesquared_ps(__m256 cplxValue1, __m256 cplxValue2){
++- __m256 complex1, complex2;
++- cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
++- cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
++- complex1 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
++- complex2 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
++- return _mm256_hadd_ps(complex1, complex2); // Add the I2 and Q2 values
+++static inline __m256 _mm256_magnitudesquared_ps(__m256 cplxValue1, __m256 cplxValue2)
+++{
+++ __m256 complex1, complex2;
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
+++ complex1 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
+++ complex2 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
+++ return _mm256_hadd_ps(complex1, complex2); // Add the I2 and Q2 values
++ }
++
++-static inline __m256
++-_mm256_magnitude_ps(__m256 cplxValue1, __m256 cplxValue2){
++- return _mm256_sqrt_ps(_mm256_magnitudesquared_ps(cplxValue1, cplxValue2));
+++static inline __m256 _mm256_magnitude_ps(__m256 cplxValue1, __m256 cplxValue2)
+++{
+++ return _mm256_sqrt_ps(_mm256_magnitudesquared_ps(cplxValue1, cplxValue2));
++ }
++
++-static inline __m256
++-_mm256_scaled_norm_dist_ps(const __m256 symbols0, const __m256 symbols1, const __m256 points0, const __m256 points1, const __m256 scalar){
++- /*
++- * Calculate: |y - x|^2 * SNR_lin
++- * Consider 'symbolsX' and 'pointsX' to be complex float
++- * 'symbolsX' are 'y' and 'pointsX' are 'x'
++- */
++- const __m256 diff0 = _mm256_sub_ps(symbols0, points0);
++- const __m256 diff1 = _mm256_sub_ps(symbols1, points1);
++- const __m256 norms = _mm256_magnitudesquared_ps(diff0, diff1);
++- return _mm256_mul_ps(norms, scalar);
+++static inline __m256 _mm256_scaled_norm_dist_ps(const __m256 symbols0,
+++ const __m256 symbols1,
+++ const __m256 points0,
+++ const __m256 points1,
+++ const __m256 scalar)
+++{
+++ /*
+++ * Calculate: |y - x|^2 * SNR_lin
+++ * Consider 'symbolsX' and 'pointsX' to be complex float
+++ * 'symbolsX' are 'y' and 'pointsX' are 'x'
+++ */
+++ const __m256 diff0 = _mm256_sub_ps(symbols0, points0);
+++ const __m256 diff1 = _mm256_sub_ps(symbols1, points1);
+++ const __m256 norms = _mm256_magnitudesquared_ps(diff0, diff1);
+++ return _mm256_mul_ps(norms, scalar);
++ }
++
++-static inline __m256
++-_mm256_polar_sign_mask(__m128i fbits){
++- __m256 sign_mask_dummy = _mm256_setzero_ps();
++- const __m128i zeros = _mm_set1_epi8(0x00);
++- const __m128i sign_extract = _mm_set1_epi8(0x80);
++- const __m128i shuffle_mask0 = _mm_setr_epi8(0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x02, 0xff, 0xff, 0xff, 0x03);
++- const __m128i shuffle_mask1 = _mm_setr_epi8(0xff, 0xff, 0xff, 0x04, 0xff, 0xff, 0xff, 0x05, 0xff, 0xff, 0xff, 0x06, 0xff, 0xff, 0xff, 0x07);
++-
++- fbits = _mm_cmpgt_epi8(fbits, zeros);
++- fbits = _mm_and_si128(fbits, sign_extract);
++- __m128i sign_bits0 = _mm_shuffle_epi8(fbits, shuffle_mask0);
++- __m128i sign_bits1 = _mm_shuffle_epi8(fbits, shuffle_mask1);
++-
++- __m256 sign_mask = _mm256_insertf128_ps(sign_mask_dummy, _mm_castsi128_ps(sign_bits0), 0x0);
++- return _mm256_insertf128_ps(sign_mask, _mm_castsi128_ps(sign_bits1), 0x1);
++-// // This is the desired function call. Though it seems to be missing in GCC.
++-// // Compare: https://software.intel.com/sites/landingpage/IntrinsicsGuide/#
++-// return _mm256_set_m128(_mm_castsi128_ps(sign_bits1), _mm_castsi128_ps(sign_bits0));
+++static inline __m256 _mm256_polar_sign_mask(__m128i fbits)
+++{
+++ __m256 sign_mask_dummy = _mm256_setzero_ps();
+++ const __m128i zeros = _mm_set1_epi8(0x00);
+++ const __m128i sign_extract = _mm_set1_epi8(0x80);
+++ const __m128i shuffle_mask0 = _mm_setr_epi8(0xff,
+++ 0xff,
+++ 0xff,
+++ 0x00,
+++ 0xff,
+++ 0xff,
+++ 0xff,
+++ 0x01,
+++ 0xff,
+++ 0xff,
+++ 0xff,
+++ 0x02,
+++ 0xff,
+++ 0xff,
+++ 0xff,
+++ 0x03);
+++ const __m128i shuffle_mask1 = _mm_setr_epi8(0xff,
+++ 0xff,
+++ 0xff,
+++ 0x04,
+++ 0xff,
+++ 0xff,
+++ 0xff,
+++ 0x05,
+++ 0xff,
+++ 0xff,
+++ 0xff,
+++ 0x06,
+++ 0xff,
+++ 0xff,
+++ 0xff,
+++ 0x07);
+++
+++ fbits = _mm_cmpgt_epi8(fbits, zeros);
+++ fbits = _mm_and_si128(fbits, sign_extract);
+++ __m128i sign_bits0 = _mm_shuffle_epi8(fbits, shuffle_mask0);
+++ __m128i sign_bits1 = _mm_shuffle_epi8(fbits, shuffle_mask1);
+++
+++ __m256 sign_mask =
+++ _mm256_insertf128_ps(sign_mask_dummy, _mm_castsi128_ps(sign_bits0), 0x0);
+++ return _mm256_insertf128_ps(sign_mask, _mm_castsi128_ps(sign_bits1), 0x1);
+++ // // This is the desired function call. Though it seems to be missing in GCC.
+++ // // Compare: https://software.intel.com/sites/landingpage/IntrinsicsGuide/#
+++ // return _mm256_set_m128(_mm_castsi128_ps(sign_bits1),
+++ // _mm_castsi128_ps(sign_bits0));
++ }
++
++ static inline void
++-_mm256_polar_deinterleave(__m256 *llr0, __m256 *llr1, __m256 src0, __m256 src1){
+++_mm256_polar_deinterleave(__m256* llr0, __m256* llr1, __m256 src0, __m256 src1)
+++{
++ // deinterleave values
++ __m256 part0 = _mm256_permute2f128_ps(src0, src1, 0x20);
++ __m256 part1 = _mm256_permute2f128_ps(src0, src1, 0x31);
++@@ -120,22 +156,25 @@ _mm256_polar_deinterleave(__m256 *llr0, __m256 *llr1, __m256 src0, __m256 src1){
++ *llr1 = _mm256_shuffle_ps(part0, part1, 0xdd);
++ }
++
++-static inline __m256
++-_mm256_polar_minsum_llrs(__m256 src0, __m256 src1){
+++static inline __m256 _mm256_polar_minsum_llrs(__m256 src0, __m256 src1)
+++{
++ const __m256 sign_mask = _mm256_set1_ps(-0.0f);
++- const __m256 abs_mask = _mm256_andnot_ps(sign_mask, _mm256_castsi256_ps(_mm256_set1_epi8(0xff)));
+++ const __m256 abs_mask =
+++ _mm256_andnot_ps(sign_mask, _mm256_castsi256_ps(_mm256_set1_epi8(0xff)));
++
++ __m256 llr0, llr1;
++ _mm256_polar_deinterleave(&llr0, &llr1, src0, src1);
++
++ // calculate result
++- __m256 sign = _mm256_xor_ps(_mm256_and_ps(llr0, sign_mask), _mm256_and_ps(llr1, sign_mask));
++- __m256 dst = _mm256_min_ps(_mm256_and_ps(llr0, abs_mask), _mm256_and_ps(llr1, abs_mask));
+++ __m256 sign =
+++ _mm256_xor_ps(_mm256_and_ps(llr0, sign_mask), _mm256_and_ps(llr1, sign_mask));
+++ __m256 dst =
+++ _mm256_min_ps(_mm256_and_ps(llr0, abs_mask), _mm256_and_ps(llr1, abs_mask));
++ return _mm256_or_ps(dst, sign);
++ }
++
++-static inline __m256
++-_mm256_polar_fsign_add_llrs(__m256 src0, __m256 src1, __m128i fbits){
+++static inline __m256 _mm256_polar_fsign_add_llrs(__m256 src0, __m256 src1, __m128i fbits)
+++{
++ // prepare sign mask for correct +-
++ __m256 sign_mask = _mm256_polar_sign_mask(fbits);
++
++diff --git a/include/volk/volk_common.h b/include/volk/volk_common.h
++index 50ea07b..8167d23 100644
++--- a/include/volk/volk_common.h
+++++ b/include/volk/volk_common.h
++@@ -18,61 +18,71 @@
++ // AppleClang also defines __GNUC__, so do this check first. These
++ // will probably be the same as for __GNUC__, but let's keep them
++ // separate just to be safe.
++-# define __VOLK_ATTR_ALIGNED(x) __attribute__((aligned(x)))
++-# define __VOLK_ATTR_UNUSED __attribute__((unused))
++-# define __VOLK_ATTR_INLINE __attribute__((always_inline))
++-# define __VOLK_ATTR_DEPRECATED __attribute__((deprecated))
++-# define __VOLK_ASM __asm__
++-# define __VOLK_VOLATILE __volatile__
++-# define __VOLK_ATTR_EXPORT __attribute__((visibility("default")))
++-# define __VOLK_ATTR_IMPORT __attribute__((visibility("default")))
++-# define __VOLK_PREFETCH(addr) __builtin_prefetch(addr)
++-#elif defined(__GNUC__)
++-# define __VOLK_ATTR_ALIGNED(x) __attribute__((aligned(x)))
++-# define __VOLK_ATTR_UNUSED __attribute__((unused))
++-# define __VOLK_ATTR_INLINE __attribute__((always_inline))
++-# define __VOLK_ATTR_DEPRECATED __attribute__((deprecated))
++-# define __VOLK_ASM __asm__
++-# define __VOLK_VOLATILE __volatile__
++-# if __GNUC__ >= 4
++-# define __VOLK_ATTR_EXPORT __attribute__((visibility("default")))
++-# define __VOLK_ATTR_IMPORT __attribute__((visibility("default")))
++-# else
++-# define __VOLK_ATTR_EXPORT
++-# define __VOLK_ATTR_IMPORT
++-# endif
++-# define __VOLK_PREFETCH(addr) __builtin_prefetch(addr)
+++#define __VOLK_ATTR_ALIGNED(x) __attribute__((aligned(x)))
+++#define __VOLK_ATTR_UNUSED __attribute__((unused))
+++#define __VOLK_ATTR_INLINE __attribute__((always_inline))
+++#define __VOLK_ATTR_DEPRECATED __attribute__((deprecated))
+++#define __VOLK_ASM __asm__
+++#define __VOLK_VOLATILE __volatile__
+++#define __VOLK_ATTR_EXPORT __attribute__((visibility("default")))
+++#define __VOLK_ATTR_IMPORT __attribute__((visibility("default")))
+++#define __VOLK_PREFETCH(addr) __builtin_prefetch(addr)
+++#elif defined __GNUC__
+++#define __VOLK_ATTR_ALIGNED(x) __attribute__((aligned(x)))
+++#define __VOLK_ATTR_UNUSED __attribute__((unused))
+++#define __VOLK_ATTR_INLINE __attribute__((always_inline))
+++#define __VOLK_ATTR_DEPRECATED __attribute__((deprecated))
+++#define __VOLK_ASM __asm__
+++#define __VOLK_VOLATILE __volatile__
+++#if __GNUC__ >= 4
+++#define __VOLK_ATTR_EXPORT __attribute__((visibility("default")))
+++#define __VOLK_ATTR_IMPORT __attribute__((visibility("default")))
++ #else
++-# warning "Unknown compiler. Using default VOLK macros, which may or not work."
++-# define __VOLK_ATTR_ALIGNED(x)
++-# define __VOLK_ATTR_UNUSED
++-# define __VOLK_ATTR_INLINE
++-# define __VOLK_ATTR_DEPRECATED
++-# define __VOLK_ATTR_EXPORT
++-# define __VOLK_ATTR_IMPORT
++-# define __VOLK_PREFETCH(addr)
++-# define __VOLK_ASM __asm__
++-# define __VOLK_VOLATILE __volatile__
+++#define __VOLK_ATTR_EXPORT
+++#define __VOLK_ATTR_IMPORT
+++#endif
+++#define __VOLK_PREFETCH(addr) __builtin_prefetch(addr)
+++#elif _MSC_VER
+++#define __VOLK_ATTR_ALIGNED(x) __declspec(align(x))
+++#define __VOLK_ATTR_UNUSED
+++#define __VOLK_ATTR_INLINE __forceinline
+++#define __VOLK_ATTR_DEPRECATED __declspec(deprecated)
+++#define __VOLK_ATTR_EXPORT __declspec(dllexport)
+++#define __VOLK_ATTR_IMPORT __declspec(dllimport)
+++#define __VOLK_PREFETCH(addr)
+++#define __VOLK_ASM __asm
+++#define __VOLK_VOLATILE
+++#else
+++#define __VOLK_ATTR_ALIGNED(x)
+++#define __VOLK_ATTR_UNUSED
+++#define __VOLK_ATTR_INLINE
+++#define __VOLK_ATTR_DEPRECATED
+++#define __VOLK_ATTR_EXPORT
+++#define __VOLK_ATTR_IMPORT
+++#define __VOLK_PREFETCH(addr)
+++#define __VOLK_ASM __asm__
+++#define __VOLK_VOLATILE __volatile__
++ #endif
++
++ ////////////////////////////////////////////////////////////////////////
++ // Ignore annoying warnings in MSVC
++ ////////////////////////////////////////////////////////////////////////
++ #if defined(_MSC_VER)
++-# pragma warning(disable: 4244) //'conversion' conversion from 'type1' to 'type2', possible loss of data
++-# pragma warning(disable: 4305) //'identifier' : truncation from 'type1' to 'type2'
+++#pragma warning(disable : 4244) //'conversion' conversion from 'type1' to 'type2',
+++ //possible loss of data
+++#pragma warning(disable : 4305) //'identifier' : truncation from 'type1' to 'type2'
++ #endif
++
++ ////////////////////////////////////////////////////////////////////////
++ // C-linkage declaration macros
++ // FIXME: due to the usage of complex.h, require gcc for c-linkage
++ ////////////////////////////////////////////////////////////////////////
++-#if defined(__cplusplus) && (defined(__GNUC__) || defined(__clang__))
++-# define __VOLK_DECL_BEGIN extern "C" {
++-# define __VOLK_DECL_END }
+++#if defined(__cplusplus) && (__GNUC__)
+++#define __VOLK_DECL_BEGIN extern "C" {
+++#define __VOLK_DECL_END }
++ #else
++-# define __VOLK_DECL_BEGIN
++-# define __VOLK_DECL_END
+++#define __VOLK_DECL_BEGIN
+++#define __VOLK_DECL_END
++ #endif
++
++ ////////////////////////////////////////////////////////////////////////
++@@ -80,9 +90,9 @@
++ // http://gcc.gnu.org/wiki/Visibility
++ ////////////////////////////////////////////////////////////////////////
++ #ifdef volk_EXPORTS
++-# define VOLK_API __VOLK_ATTR_EXPORT
+++#define VOLK_API __VOLK_ATTR_EXPORT
++ #else
++-# define VOLK_API __VOLK_ATTR_IMPORT
+++#define VOLK_API __VOLK_ATTR_IMPORT
++ #endif
++
++ ////////////////////////////////////////////////////////////////////////
++@@ -98,38 +108,38 @@
++ #endif
++ #endif
++
++-union bit128{
++- uint8_t i8[16];
++- uint16_t i16[8];
++- uint32_t i[4];
++- float f[4];
++- double d[2];
+++union bit128 {
+++ uint8_t i8[16];
+++ uint16_t i16[8];
+++ uint32_t i[4];
+++ float f[4];
+++ double d[2];
++
++- #ifdef LV_HAVE_SSE
++- __m128 float_vec;
++- #endif
+++#ifdef LV_HAVE_SSE
+++ __m128 float_vec;
+++#endif
++
++- #ifdef LV_HAVE_SSE2
++- __m128i int_vec;
++- __m128d double_vec;
++- #endif
+++#ifdef LV_HAVE_SSE2
+++ __m128i int_vec;
+++ __m128d double_vec;
+++#endif
++ };
++
++-union bit256{
++- uint8_t i8[32];
++- uint16_t i16[16];
++- uint32_t i[8];
++- float f[8];
++- double d[4];
+++union bit256 {
+++ uint8_t i8[32];
+++ uint16_t i16[16];
+++ uint32_t i[8];
+++ float f[8];
+++ double d[4];
++
++- #ifdef LV_HAVE_AVX
++- __m256 float_vec;
++- __m256i int_vec;
++- __m256d double_vec;
++- #endif
+++#ifdef LV_HAVE_AVX
+++ __m256 float_vec;
+++ __m256i int_vec;
+++ __m256d double_vec;
+++#endif
++ };
++
++-#define bit128_p(x) ((union bit128 *)(x))
++-#define bit256_p(x) ((union bit256 *)(x))
+++#define bit128_p(x) ((union bit128*)(x))
+++#define bit256_p(x) ((union bit256*)(x))
++
++ #endif /*INCLUDED_LIBVOLK_COMMON_H*/
++diff --git a/include/volk/volk_complex.h b/include/volk/volk_complex.h
++index 1d61d78..ae78873 100644
++--- a/include/volk/volk_complex.h
+++++ b/include/volk/volk_complex.h
++@@ -19,49 +19,58 @@
++
++ #ifdef __cplusplus
++
++-#include <complex>
++ #include <stdint.h>
+++#include <complex>
++
++-typedef std::complex<int8_t> lv_8sc_t;
+++typedef std::complex<int8_t> lv_8sc_t;
++ typedef std::complex<int16_t> lv_16sc_t;
++ typedef std::complex<int32_t> lv_32sc_t;
++ typedef std::complex<int64_t> lv_64sc_t;
++-typedef std::complex<float> lv_32fc_t;
++-typedef std::complex<double> lv_64fc_t;
+++typedef std::complex<float> lv_32fc_t;
+++typedef std::complex<double> lv_64fc_t;
++
++-template <typename T> inline std::complex<T> lv_cmake(const T &r, const T &i){
+++template <typename T>
+++inline std::complex<T> lv_cmake(const T& r, const T& i)
+++{
++ return std::complex<T>(r, i);
++ }
++
++-template <typename T> inline typename T::value_type lv_creal(const T &x){
+++template <typename T>
+++inline typename T::value_type lv_creal(const T& x)
+++{
++ return x.real();
++ }
++
++-template <typename T> inline typename T::value_type lv_cimag(const T &x){
+++template <typename T>
+++inline typename T::value_type lv_cimag(const T& x)
+++{
++ return x.imag();
++ }
++
++-template <typename T> inline T lv_conj(const T &x){
+++template <typename T>
+++inline T lv_conj(const T& x)
+++{
++ return std::conj(x);
++ }
++
++ #else /* __cplusplus */
++
++ #if __STDC_VERSION__ >= 199901L /* C99 check */
++-/* this allows us to conj in lv_conj without the double detour for single-precision floats */
+++/* this allows us to conj in lv_conj without the double detour for single-precision floats
+++ */
++ #include <tgmath.h>
++ #endif /* C99 check */
++
++ #include <complex.h>
++
++-typedef char complex lv_8sc_t;
++-typedef short complex lv_16sc_t;
++-typedef long complex lv_32sc_t;
++-typedef long long complex lv_64sc_t;
++-typedef float complex lv_32fc_t;
++-typedef double complex lv_64fc_t;
+++typedef char complex lv_8sc_t;
+++typedef short complex lv_16sc_t;
+++typedef long complex lv_32sc_t;
+++typedef long long complex lv_64sc_t;
+++typedef float complex lv_32fc_t;
+++typedef double complex lv_64fc_t;
++
++-#define lv_cmake(r, i) ((r) + _Complex_I*(i))
+++#define lv_cmake(r, i) ((r) + _Complex_I * (i))
++
++ // When GNUC is available, use the complex extensions.
++ // The extensions always return the correct value type.
++diff --git a/include/volk/volk_malloc.h b/include/volk/volk_malloc.h
++index 3477b27..42ca2b0 100644
++--- a/include/volk/volk_malloc.h
+++++ b/include/volk/volk_malloc.h
++@@ -23,8 +23,8 @@
++ #ifndef INCLUDED_VOLK_MALLOC_H
++ #define INCLUDED_VOLK_MALLOC_H
++
++-#include <volk/volk_common.h>
++ #include <stdlib.h>
+++#include <volk/volk_common.h>
++
++ __VOLK_DECL_BEGIN
++
++@@ -40,7 +40,8 @@ __VOLK_DECL_BEGIN
++ * For Apple Clang, we fall back to `posix_memalign`.
++ * see: https://linux.die.net/man/3/aligned_alloc
++ * For MSVC, we fall back to `_aligned_malloc`.
++- * see: https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/aligned-malloc?view=vs-2019
+++ * see:
+++ * https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/aligned-malloc?view=vs-2019
++ *
++ * Because of the ways in which volk_malloc may allocate memory, it is
++ * important to always free volk_malloc pointers using volk_free.
++@@ -51,7 +52,7 @@ __VOLK_DECL_BEGIN
++ * \param alignment The byte alignment of the allocated memory.
++ * \return pointer to aligned memory.
++ */
++-VOLK_API void *volk_malloc(size_t size, size_t alignment);
+++VOLK_API void* volk_malloc(size_t size, size_t alignment);
++
++ /*!
++ * \brief Free's memory allocated by volk_malloc.
++@@ -62,11 +63,12 @@ VOLK_API void *volk_malloc(size_t size, size_t alignment);
++ * Thus, in this case `volk_free` inherits the same behavior `free` exhibits.
++ * see: https://en.cppreference.com/w/c/memory/free
++ * In case `_aligned_malloc` was used, we call `_aligned_free`.
++- * see: https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/aligned-free?view=vs-2019
+++ * see:
+++ * https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/aligned-free?view=vs-2019
++ *
++ * \param aptr The aligned pointer allocated by volk_malloc.
++ */
++-VOLK_API void volk_free(void *aptr);
+++VOLK_API void volk_free(void* aptr);
++
++ __VOLK_DECL_END
++
++diff --git a/include/volk/volk_neon_intrinsics.h b/include/volk/volk_neon_intrinsics.h
++index 90e7b54..302bd30 100644
++--- a/include/volk/volk_neon_intrinsics.h
+++++ b/include/volk/volk_neon_intrinsics.h
++@@ -67,9 +67,9 @@
++ 3. This notice may not be removed or altered from any source distribution.
++
++ (this is the zlib license)
++-
+++
++ _vsincosq_f32
++-
+++
++ */
++
++ /*
++@@ -83,13 +83,12 @@
++
++
++ /* Magnitude squared for float32x4x2_t */
++-static inline float32x4_t
++-_vmagnitudesquaredq_f32(float32x4x2_t cmplxValue)
+++static inline float32x4_t _vmagnitudesquaredq_f32(float32x4x2_t cmplxValue)
++ {
++ float32x4_t iValue, qValue, result;
++ iValue = vmulq_f32(cmplxValue.val[0], cmplxValue.val[0]); // Square the values
++ qValue = vmulq_f32(cmplxValue.val[1], cmplxValue.val[1]); // Square the values
++- result = vaddq_f32(iValue, qValue); // Add the I2 and Q2 values
+++ result = vaddq_f32(iValue, qValue); // Add the I2 and Q2 values
++ return result;
++ }
++
++@@ -97,9 +96,11 @@ _vmagnitudesquaredq_f32(float32x4x2_t cmplxValue)
++ static inline float32x4_t _vinvsqrtq_f32(float32x4_t x)
++ {
++ float32x4_t sqrt_reciprocal = vrsqrteq_f32(x);
++- sqrt_reciprocal = vmulq_f32(vrsqrtsq_f32(vmulq_f32(x, sqrt_reciprocal), sqrt_reciprocal), sqrt_reciprocal);
++- sqrt_reciprocal = vmulq_f32(vrsqrtsq_f32(vmulq_f32(x, sqrt_reciprocal), sqrt_reciprocal), sqrt_reciprocal);
++-
+++ sqrt_reciprocal = vmulq_f32(
+++ vrsqrtsq_f32(vmulq_f32(x, sqrt_reciprocal), sqrt_reciprocal), sqrt_reciprocal);
+++ sqrt_reciprocal = vmulq_f32(
+++ vrsqrtsq_f32(vmulq_f32(x, sqrt_reciprocal), sqrt_reciprocal), sqrt_reciprocal);
+++
++ return sqrt_reciprocal;
++ }
++
++@@ -108,19 +109,19 @@ static inline float32x4_t _vinvq_f32(float32x4_t x)
++ {
++ // Newton's method
++ float32x4_t recip = vrecpeq_f32(x);
++- recip = vmulq_f32(vrecpsq_f32(x, recip), recip);
++- recip = vmulq_f32(vrecpsq_f32(x, recip), recip);
+++ recip = vmulq_f32(vrecpsq_f32(x, recip), recip);
+++ recip = vmulq_f32(vrecpsq_f32(x, recip), recip);
++ return recip;
++ }
++
++ /* Complex multiplication for float32x4x2_t */
++-static inline float32x4x2_t
++-_vmultiply_complexq_f32(float32x4x2_t a_val, float32x4x2_t b_val)
+++static inline float32x4x2_t _vmultiply_complexq_f32(float32x4x2_t a_val,
+++ float32x4x2_t b_val)
++ {
++ float32x4x2_t tmp_real;
++ float32x4x2_t tmp_imag;
++ float32x4x2_t c_val;
++-
+++
++ // multiply the real*real and imag*imag to get real result
++ // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
++ tmp_real.val[0] = vmulq_f32(a_val.val[0], b_val.val[0]);
++@@ -140,12 +141,12 @@ _vmultiply_complexq_f32(float32x4x2_t a_val, float32x4x2_t b_val)
++ /* From ARM Compute Library, MIT license */
++ static inline float32x4_t _vtaylor_polyq_f32(float32x4_t x, const float32x4_t coeffs[8])
++ {
++- float32x4_t cA = vmlaq_f32(coeffs[0], coeffs[4], x);
++- float32x4_t cB = vmlaq_f32(coeffs[2], coeffs[6], x);
++- float32x4_t cC = vmlaq_f32(coeffs[1], coeffs[5], x);
++- float32x4_t cD = vmlaq_f32(coeffs[3], coeffs[7], x);
++- float32x4_t x2 = vmulq_f32(x, x);
++- float32x4_t x4 = vmulq_f32(x2, x2);
+++ float32x4_t cA = vmlaq_f32(coeffs[0], coeffs[4], x);
+++ float32x4_t cB = vmlaq_f32(coeffs[2], coeffs[6], x);
+++ float32x4_t cC = vmlaq_f32(coeffs[1], coeffs[5], x);
+++ float32x4_t cD = vmlaq_f32(coeffs[3], coeffs[7], x);
+++ float32x4_t x2 = vmulq_f32(x, x);
+++ float32x4_t x4 = vmulq_f32(x2, x2);
++ float32x4_t res = vmlaq_f32(vmlaq_f32(cA, cB, x2), vmlaq_f32(cC, cD, x2), x4);
++ return res;
++ }
++@@ -155,121 +156,123 @@ static inline float32x4_t _vtaylor_polyq_f32(float32x4_t x, const float32x4_t co
++ static inline float32x4_t _vlogq_f32(float32x4_t x)
++ {
++ const float32x4_t log_tab[8] = {
++- vdupq_n_f32(-2.29561495781f),
++- vdupq_n_f32(-2.47071170807f),
++- vdupq_n_f32(-5.68692588806f),
++- vdupq_n_f32(-0.165253549814f),
++- vdupq_n_f32(5.17591238022f),
++- vdupq_n_f32(0.844007015228f),
++- vdupq_n_f32(4.58445882797f),
++- vdupq_n_f32(0.0141278216615f),
+++ vdupq_n_f32(-2.29561495781f), vdupq_n_f32(-2.47071170807f),
+++ vdupq_n_f32(-5.68692588806f), vdupq_n_f32(-0.165253549814f),
+++ vdupq_n_f32(5.17591238022f), vdupq_n_f32(0.844007015228f),
+++ vdupq_n_f32(4.58445882797f), vdupq_n_f32(0.0141278216615f),
++ };
++-
++- const int32x4_t CONST_127 = vdupq_n_s32(127); // 127
+++
+++ const int32x4_t CONST_127 = vdupq_n_s32(127); // 127
++ const float32x4_t CONST_LN2 = vdupq_n_f32(0.6931471805f); // ln(2)
++-
+++
++ // Extract exponent
++- int32x4_t m = vsubq_s32(vreinterpretq_s32_u32(vshrq_n_u32(vreinterpretq_u32_f32(x), 23)), CONST_127);
++- float32x4_t val = vreinterpretq_f32_s32(vsubq_s32(vreinterpretq_s32_f32(x), vshlq_n_s32(m, 23)));
++-
+++ int32x4_t m = vsubq_s32(
+++ vreinterpretq_s32_u32(vshrq_n_u32(vreinterpretq_u32_f32(x), 23)), CONST_127);
+++ float32x4_t val =
+++ vreinterpretq_f32_s32(vsubq_s32(vreinterpretq_s32_f32(x), vshlq_n_s32(m, 23)));
+++
++ // Polynomial Approximation
++ float32x4_t poly = _vtaylor_polyq_f32(val, log_tab);
++-
+++
++ // Reconstruct
++ poly = vmlaq_f32(poly, vcvtq_f32_s32(m), CONST_LN2);
++-
+++
++ return poly;
++ }
++
++ /* Evaluation of 4 sines & cosines at once.
++ * Optimized from here (zlib license)
++ * http://gruntthepeon.free.fr/ssemath/ */
++-static inline float32x4x2_t _vsincosq_f32(float32x4_t x) {
+++static inline float32x4x2_t _vsincosq_f32(float32x4_t x)
+++{
++ const float32x4_t c_minus_cephes_DP1 = vdupq_n_f32(-0.78515625);
++ const float32x4_t c_minus_cephes_DP2 = vdupq_n_f32(-2.4187564849853515625e-4);
++ const float32x4_t c_minus_cephes_DP3 = vdupq_n_f32(-3.77489497744594108e-8);
++ const float32x4_t c_sincof_p0 = vdupq_n_f32(-1.9515295891e-4);
++- const float32x4_t c_sincof_p1 = vdupq_n_f32(8.3321608736e-3);
+++ const float32x4_t c_sincof_p1 = vdupq_n_f32(8.3321608736e-3);
++ const float32x4_t c_sincof_p2 = vdupq_n_f32(-1.6666654611e-1);
++ const float32x4_t c_coscof_p0 = vdupq_n_f32(2.443315711809948e-005);
++ const float32x4_t c_coscof_p1 = vdupq_n_f32(-1.388731625493765e-003);
++ const float32x4_t c_coscof_p2 = vdupq_n_f32(4.166664568298827e-002);
++ const float32x4_t c_cephes_FOPI = vdupq_n_f32(1.27323954473516); // 4 / M_PI
++-
+++
++ const float32x4_t CONST_1 = vdupq_n_f32(1.f);
++ const float32x4_t CONST_1_2 = vdupq_n_f32(0.5f);
++ const float32x4_t CONST_0 = vdupq_n_f32(0.f);
++- const uint32x4_t CONST_2 = vdupq_n_u32(2);
++- const uint32x4_t CONST_4 = vdupq_n_u32(4);
++-
+++ const uint32x4_t CONST_2 = vdupq_n_u32(2);
+++ const uint32x4_t CONST_4 = vdupq_n_u32(4);
+++
++ uint32x4_t emm2;
++-
+++
++ uint32x4_t sign_mask_sin, sign_mask_cos;
++ sign_mask_sin = vcltq_f32(x, CONST_0);
++ x = vabsq_f32(x);
++ // scale by 4/pi
++ float32x4_t y = vmulq_f32(x, c_cephes_FOPI);
++-
+++
++ // store the integer part of y in mm0
++ emm2 = vcvtq_u32_f32(y);
++ /* j=(j+1) & (~1) (see the cephes sources) */
++ emm2 = vaddq_u32(emm2, vdupq_n_u32(1));
++ emm2 = vandq_u32(emm2, vdupq_n_u32(~1));
++ y = vcvtq_f32_u32(emm2);
++-
+++
++ /* get the polynom selection mask
++ there is one polynom for 0 <= x <= Pi/4
++ and another one for Pi/4<x<=Pi/2
++ Both branches will be computed. */
++ const uint32x4_t poly_mask = vtstq_u32(emm2, CONST_2);
++-
+++
++ // The magic pass: "Extended precision modular arithmetic"
++ x = vmlaq_f32(x, y, c_minus_cephes_DP1);
++ x = vmlaq_f32(x, y, c_minus_cephes_DP2);
++ x = vmlaq_f32(x, y, c_minus_cephes_DP3);
++-
+++
++ sign_mask_sin = veorq_u32(sign_mask_sin, vtstq_u32(emm2, CONST_4));
++ sign_mask_cos = vtstq_u32(vsubq_u32(emm2, CONST_2), CONST_4);
++-
+++
++ /* Evaluate the first polynom (0 <= x <= Pi/4) in y1,
++ and the second polynom (Pi/4 <= x <= 0) in y2 */
++ float32x4_t y1, y2;
++- float32x4_t z = vmulq_f32(x,x);
++-
+++ float32x4_t z = vmulq_f32(x, x);
+++
++ y1 = vmlaq_f32(c_coscof_p1, z, c_coscof_p0);
++ y1 = vmlaq_f32(c_coscof_p2, z, y1);
++ y1 = vmulq_f32(y1, z);
++ y1 = vmulq_f32(y1, z);
++ y1 = vmlsq_f32(y1, z, CONST_1_2);
++ y1 = vaddq_f32(y1, CONST_1);
++-
+++
++ y2 = vmlaq_f32(c_sincof_p1, z, c_sincof_p0);
++ y2 = vmlaq_f32(c_sincof_p2, z, y2);
++ y2 = vmulq_f32(y2, z);
++ y2 = vmlaq_f32(x, x, y2);
++-
+++
++ /* select the correct result from the two polynoms */
++ const float32x4_t ys = vbslq_f32(poly_mask, y1, y2);
++ const float32x4_t yc = vbslq_f32(poly_mask, y2, y1);
++-
+++
++ float32x4x2_t sincos;
++ sincos.val[0] = vbslq_f32(sign_mask_sin, vnegq_f32(ys), ys);
++ sincos.val[1] = vbslq_f32(sign_mask_cos, yc, vnegq_f32(yc));
++-
+++
++ return sincos;
++ }
++
++-static inline float32x4_t _vsinq_f32(float32x4_t x) {
+++static inline float32x4_t _vsinq_f32(float32x4_t x)
+++{
++ const float32x4x2_t sincos = _vsincosq_f32(x);
++ return sincos.val[0];
++ }
++
++-static inline float32x4_t _vcosq_f32(float32x4_t x) {
+++static inline float32x4_t _vcosq_f32(float32x4_t x)
+++{
++ const float32x4x2_t sincos = _vsincosq_f32(x);
++ return sincos.val[1];
++ }
++
++-static inline float32x4_t _vtanq_f32(float32x4_t x) {
+++static inline float32x4_t _vtanq_f32(float32x4_t x)
+++{
++ const float32x4x2_t sincos = _vsincosq_f32(x);
++ return vmulq_f32(sincos.val[0], _vinvq_f32(sincos.val[1]));
++ }
++diff --git a/include/volk/volk_prefs.h b/include/volk/volk_prefs.h
++index cfa3806..96b7f1c 100644
++--- a/include/volk/volk_prefs.h
+++++ b/include/volk/volk_prefs.h
++@@ -1,17 +1,16 @@
++ #ifndef INCLUDED_VOLK_PREFS_H
++ #define INCLUDED_VOLK_PREFS_H
++
++-#include <volk/volk_common.h>
++ #include <stdbool.h>
++ #include <stdlib.h>
+++#include <volk/volk_common.h>
++
++ __VOLK_DECL_BEGIN
++
++-typedef struct volk_arch_pref
++-{
++- char name[128]; //name of the kernel
++- char impl_a[128]; //best aligned impl
++- char impl_u[128]; //best unaligned impl
+++typedef struct volk_arch_pref {
+++ char name[128]; // name of the kernel
+++ char impl_a[128]; // best aligned impl
+++ char impl_u[128]; // best unaligned impl
++ } volk_arch_pref_t;
++
++ ////////////////////////////////////////////////////////////////////////
++@@ -19,13 +18,13 @@ typedef struct volk_arch_pref
++ // if config file should be tested on existence for reading.
++ // returns \0 in the argument on failure.
++ ////////////////////////////////////////////////////////////////////////
++-VOLK_API void volk_get_config_path(char *, bool);
+++VOLK_API void volk_get_config_path(char*, bool);
++
++ ////////////////////////////////////////////////////////////////////////
++ // load prefs into global prefs struct
++ ////////////////////////////////////////////////////////////////////////
++-VOLK_API size_t volk_load_preferences(volk_arch_pref_t **);
+++VOLK_API size_t volk_load_preferences(volk_arch_pref_t**);
++
++ __VOLK_DECL_END
++
++-#endif //INCLUDED_VOLK_PREFS_H
+++#endif // INCLUDED_VOLK_PREFS_H
++diff --git a/include/volk/volk_sse3_intrinsics.h b/include/volk/volk_sse3_intrinsics.h
++index 6b53a2a..6bdc8d8 100644
++--- a/include/volk/volk_sse3_intrinsics.h
+++++ b/include/volk/volk_sse3_intrinsics.h
++@@ -1,19 +1,19 @@
++ /* -*- c++ -*- */
++-/*
+++/*
++ * Copyright 2015 Free Software Foundation, Inc.
++- *
+++ *
++ * This file is part of GNU Radio
++- *
+++ *
++ * GNU Radio is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 3, or (at your option)
++ * any later version.
++- *
+++ *
++ * GNU Radio is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++- *
+++ *
++ * You should have received a copy of the GNU General Public License
++ * along with GNU Radio; see the file COPYING. If not, write to
++ * the Free Software Foundation, Inc., 51 Franklin Street,
++@@ -29,49 +29,52 @@
++ #define INCLUDE_VOLK_VOLK_SSE3_INTRINSICS_H_
++ #include <pmmintrin.h>
++
++-static inline __m128
++-_mm_complexmul_ps(__m128 x, __m128 y)
+++static inline __m128 _mm_complexmul_ps(__m128 x, __m128 y)
++ {
++- __m128 yl, yh, tmp1, tmp2;
++- yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr
++- yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di
++- tmp1 = _mm_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
++- x = _mm_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br
++- tmp2 = _mm_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
++- return _mm_addsub_ps(tmp1, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ __m128 yl, yh, tmp1, tmp2;
+++ yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr
+++ yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di
+++ tmp1 = _mm_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+++ x = _mm_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br
+++ tmp2 = _mm_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+++ return _mm_addsub_ps(tmp1,
+++ tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++ }
++
++-static inline __m128
++-_mm_complexconjugatemul_ps(__m128 x, __m128 y)
+++static inline __m128 _mm_complexconjugatemul_ps(__m128 x, __m128 y)
++ {
++- const __m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);
++- y = _mm_xor_ps(y, conjugator); // conjugate y
++- return _mm_complexmul_ps(x, y);
+++ const __m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);
+++ y = _mm_xor_ps(y, conjugator); // conjugate y
+++ return _mm_complexmul_ps(x, y);
++ }
++
++-static inline __m128
++-_mm_magnitudesquared_ps_sse3(__m128 cplxValue1, __m128 cplxValue2){
++- cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values
++- cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values
++- return _mm_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
+++static inline __m128 _mm_magnitudesquared_ps_sse3(__m128 cplxValue1, __m128 cplxValue2)
+++{
+++ cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values
+++ cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values
+++ return _mm_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
++ }
++
++-static inline __m128
++-_mm_magnitude_ps_sse3(__m128 cplxValue1, __m128 cplxValue2){
++- return _mm_sqrt_ps(_mm_magnitudesquared_ps_sse3(cplxValue1, cplxValue2));
+++static inline __m128 _mm_magnitude_ps_sse3(__m128 cplxValue1, __m128 cplxValue2)
+++{
+++ return _mm_sqrt_ps(_mm_magnitudesquared_ps_sse3(cplxValue1, cplxValue2));
++ }
++
++-static inline __m128
++-_mm_scaled_norm_dist_ps_sse3(const __m128 symbols0, const __m128 symbols1, const __m128 points0, const __m128 points1, const __m128 scalar){
++- /*
++- * Calculate: |y - x|^2 * SNR_lin
++- * Consider 'symbolsX' and 'pointsX' to be complex float
++- * 'symbolsX' are 'y' and 'pointsX' are 'x'
++- */
++- const __m128 diff0 = _mm_sub_ps(symbols0, points0);
++- const __m128 diff1 = _mm_sub_ps(symbols1, points1);
++- const __m128 norms = _mm_magnitudesquared_ps_sse3(diff0, diff1);
++- return _mm_mul_ps(norms, scalar);
+++static inline __m128 _mm_scaled_norm_dist_ps_sse3(const __m128 symbols0,
+++ const __m128 symbols1,
+++ const __m128 points0,
+++ const __m128 points1,
+++ const __m128 scalar)
+++{
+++ /*
+++ * Calculate: |y - x|^2 * SNR_lin
+++ * Consider 'symbolsX' and 'pointsX' to be complex float
+++ * 'symbolsX' are 'y' and 'pointsX' are 'x'
+++ */
+++ const __m128 diff0 = _mm_sub_ps(symbols0, points0);
+++ const __m128 diff1 = _mm_sub_ps(symbols1, points1);
+++ const __m128 norms = _mm_magnitudesquared_ps_sse3(diff0, diff1);
+++ return _mm_mul_ps(norms, scalar);
++ }
++
++ #endif /* INCLUDE_VOLK_VOLK_SSE3_INTRINSICS_H_ */
++diff --git a/include/volk/volk_sse_intrinsics.h b/include/volk/volk_sse_intrinsics.h
++index 57318e2..24fe7c1 100644
++--- a/include/volk/volk_sse_intrinsics.h
+++++ b/include/volk/volk_sse_intrinsics.h
++@@ -1,19 +1,19 @@
++ /* -*- c++ -*- */
++-/*
+++/*
++ * Copyright 2015 Free Software Foundation, Inc.
++- *
+++ *
++ * This file is part of GNU Radio
++- *
+++ *
++ * GNU Radio is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 3, or (at your option)
++ * any later version.
++- *
+++ *
++ * GNU Radio is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++- *
+++ *
++ * You should have received a copy of the GNU General Public License
++ * along with GNU Radio; see the file COPYING. If not, write to
++ * the Free Software Foundation, Inc., 51 Franklin Street,
++@@ -29,31 +29,34 @@
++ #define INCLUDE_VOLK_VOLK_SSE_INTRINSICS_H_
++ #include <xmmintrin.h>
++
++-static inline __m128
++-_mm_magnitudesquared_ps(__m128 cplxValue1, __m128 cplxValue2){
++- __m128 iValue, qValue;
++- // Arrange in i1i2i3i4 format
++- iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
++- // Arrange in q1q2q3q4 format
++- qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));
++- iValue = _mm_mul_ps(iValue, iValue); // Square the I values
++- qValue = _mm_mul_ps(qValue, qValue); // Square the Q Values
++- return _mm_add_ps(iValue, qValue); // Add the I2 and Q2 values
+++static inline __m128 _mm_magnitudesquared_ps(__m128 cplxValue1, __m128 cplxValue2)
+++{
+++ __m128 iValue, qValue;
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
+++ // Arrange in q1q2q3q4 format
+++ qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3, 1, 3, 1));
+++ iValue = _mm_mul_ps(iValue, iValue); // Square the I values
+++ qValue = _mm_mul_ps(qValue, qValue); // Square the Q Values
+++ return _mm_add_ps(iValue, qValue); // Add the I2 and Q2 values
++ }
++
++-static inline __m128
++-_mm_magnitude_ps(__m128 cplxValue1, __m128 cplxValue2){
++- return _mm_sqrt_ps(_mm_magnitudesquared_ps(cplxValue1, cplxValue2));
+++static inline __m128 _mm_magnitude_ps(__m128 cplxValue1, __m128 cplxValue2)
+++{
+++ return _mm_sqrt_ps(_mm_magnitudesquared_ps(cplxValue1, cplxValue2));
++ }
++
++-static inline __m128
++-_mm_scaled_norm_dist_ps_sse(const __m128 symbols0, const __m128 symbols1, const __m128 points0, const __m128 points1, const __m128 scalar)
+++static inline __m128 _mm_scaled_norm_dist_ps_sse(const __m128 symbols0,
+++ const __m128 symbols1,
+++ const __m128 points0,
+++ const __m128 points1,
+++ const __m128 scalar)
++ {
++- // calculate scalar * |x - y|^2
++- const __m128 diff0 = _mm_sub_ps(symbols0, points0);
++- const __m128 diff1 = _mm_sub_ps(symbols1, points1);
++- const __m128 norms = _mm_magnitudesquared_ps(diff0, diff1);
++- return _mm_mul_ps(norms, scalar);
+++ // calculate scalar * |x - y|^2
+++ const __m128 diff0 = _mm_sub_ps(symbols0, points0);
+++ const __m128 diff1 = _mm_sub_ps(symbols1, points1);
+++ const __m128 norms = _mm_magnitudesquared_ps(diff0, diff1);
+++ return _mm_mul_ps(norms, scalar);
++ }
++
++ #endif /* INCLUDE_VOLK_VOLK_SSE_INTRINSICS_H_ */
++diff --git a/kernels/volk/volk_16i_32fc_dot_prod_32fc.h b/kernels/volk/volk_16i_32fc_dot_prod_32fc.h
++index f250340..2635649 100644
++--- a/kernels/volk/volk_16i_32fc_dot_prod_32fc.h
+++++ b/kernels/volk/volk_16i_32fc_dot_prod_32fc.h
++@@ -33,8 +33,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16i_32fc_dot_prod_32fc(lv_32fc_t* result, const short* input, const lv_32fc_t * taps, unsigned int num_points)
++- * \endcode
+++ * void volk_16i_32fc_dot_prod_32fc(lv_32fc_t* result, const short* input, const lv_32fc_t
+++ * * taps, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li input: vector of shorts.
++@@ -58,165 +58,178 @@
++ #ifndef INCLUDED_volk_16i_32fc_dot_prod_32fc_H
++ #define INCLUDED_volk_16i_32fc_dot_prod_32fc_H
++
++-#include <volk/volk_common.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_16i_32fc_dot_prod_32fc_generic(lv_32fc_t* result, const short* input, const lv_32fc_t * taps, unsigned int num_points) {
+++static inline void volk_16i_32fc_dot_prod_32fc_generic(lv_32fc_t* result,
+++ const short* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- static const int N_UNROLL = 4;
+++ static const int N_UNROLL = 4;
++
++- lv_32fc_t acc0 = 0;
++- lv_32fc_t acc1 = 0;
++- lv_32fc_t acc2 = 0;
++- lv_32fc_t acc3 = 0;
+++ lv_32fc_t acc0 = 0;
+++ lv_32fc_t acc1 = 0;
+++ lv_32fc_t acc2 = 0;
+++ lv_32fc_t acc3 = 0;
++
++- unsigned i = 0;
++- unsigned n = (num_points / N_UNROLL) * N_UNROLL;
+++ unsigned i = 0;
+++ unsigned n = (num_points / N_UNROLL) * N_UNROLL;
++
++- for(i = 0; i < n; i += N_UNROLL) {
++- acc0 += taps[i + 0] * (float)input[i + 0];
++- acc1 += taps[i + 1] * (float)input[i + 1];
++- acc2 += taps[i + 2] * (float)input[i + 2];
++- acc3 += taps[i + 3] * (float)input[i + 3];
++- }
+++ for (i = 0; i < n; i += N_UNROLL) {
+++ acc0 += taps[i + 0] * (float)input[i + 0];
+++ acc1 += taps[i + 1] * (float)input[i + 1];
+++ acc2 += taps[i + 2] * (float)input[i + 2];
+++ acc3 += taps[i + 3] * (float)input[i + 3];
+++ }
++
++- for(; i < num_points; i++) {
++- acc0 += taps[i] * (float)input[i];
++- }
+++ for (; i < num_points; i++) {
+++ acc0 += taps[i] * (float)input[i];
+++ }
++
++- *result = acc0 + acc1 + acc2 + acc3;
+++ *result = acc0 + acc1 + acc2 + acc3;
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++-static inline void volk_16i_32fc_dot_prod_32fc_neon(lv_32fc_t* result, const short* input, const lv_32fc_t * taps, unsigned int num_points) {
++-
++- unsigned ii;
++- unsigned quarter_points = num_points / 4;
++- lv_32fc_t* tapsPtr = (lv_32fc_t*) taps;
++- short* inputPtr = (short*) input;
++- lv_32fc_t accumulator_vec[4];
++-
++- float32x4x2_t tapsVal, accumulator_val;
++- int16x4_t input16;
++- int32x4_t input32;
++- float32x4_t input_float, prod_re, prod_im;
++-
++- accumulator_val.val[0] = vdupq_n_f32(0.0);
++- accumulator_val.val[1] = vdupq_n_f32(0.0);
++-
++- for(ii = 0; ii < quarter_points; ++ii) {
++- tapsVal = vld2q_f32((float*)tapsPtr);
++- input16 = vld1_s16(inputPtr);
++- // widen 16-bit int to 32-bit int
++- input32 = vmovl_s16(input16);
++- // convert 32-bit int to float with scale
++- input_float = vcvtq_f32_s32(input32);
++-
++- prod_re = vmulq_f32(input_float, tapsVal.val[0]);
++- prod_im = vmulq_f32(input_float, tapsVal.val[1]);
++-
++- accumulator_val.val[0] = vaddq_f32(prod_re, accumulator_val.val[0]);
++- accumulator_val.val[1] = vaddq_f32(prod_im, accumulator_val.val[1]);
++-
++- tapsPtr += 4;
++- inputPtr += 4;
++- }
++- vst2q_f32((float*)accumulator_vec, accumulator_val);
++- accumulator_vec[0] += accumulator_vec[1];
++- accumulator_vec[2] += accumulator_vec[3];
++- accumulator_vec[0] += accumulator_vec[2];
++-
++- for(ii = quarter_points * 4; ii < num_points; ++ii) {
++- accumulator_vec[0] += *(tapsPtr++) * (float)(*(inputPtr++));
++- }
++-
++- *result = accumulator_vec[0];
+++static inline void volk_16i_32fc_dot_prod_32fc_neon(lv_32fc_t* result,
+++ const short* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned ii;
+++ unsigned quarter_points = num_points / 4;
+++ lv_32fc_t* tapsPtr = (lv_32fc_t*)taps;
+++ short* inputPtr = (short*)input;
+++ lv_32fc_t accumulator_vec[4];
+++
+++ float32x4x2_t tapsVal, accumulator_val;
+++ int16x4_t input16;
+++ int32x4_t input32;
+++ float32x4_t input_float, prod_re, prod_im;
+++
+++ accumulator_val.val[0] = vdupq_n_f32(0.0);
+++ accumulator_val.val[1] = vdupq_n_f32(0.0);
+++
+++ for (ii = 0; ii < quarter_points; ++ii) {
+++ tapsVal = vld2q_f32((float*)tapsPtr);
+++ input16 = vld1_s16(inputPtr);
+++ // widen 16-bit int to 32-bit int
+++ input32 = vmovl_s16(input16);
+++ // convert 32-bit int to float with scale
+++ input_float = vcvtq_f32_s32(input32);
+++
+++ prod_re = vmulq_f32(input_float, tapsVal.val[0]);
+++ prod_im = vmulq_f32(input_float, tapsVal.val[1]);
+++
+++ accumulator_val.val[0] = vaddq_f32(prod_re, accumulator_val.val[0]);
+++ accumulator_val.val[1] = vaddq_f32(prod_im, accumulator_val.val[1]);
+++
+++ tapsPtr += 4;
+++ inputPtr += 4;
+++ }
+++ vst2q_f32((float*)accumulator_vec, accumulator_val);
+++ accumulator_vec[0] += accumulator_vec[1];
+++ accumulator_vec[2] += accumulator_vec[3];
+++ accumulator_vec[0] += accumulator_vec[2];
+++
+++ for (ii = quarter_points * 4; ii < num_points; ++ii) {
+++ accumulator_vec[0] += *(tapsPtr++) * (float)(*(inputPtr++));
+++ }
+++
+++ *result = accumulator_vec[0];
++ }
++
++ #endif /*LV_HAVE_NEON*/
++
++ #if LV_HAVE_SSE && LV_HAVE_MMX
++
++-static inline void volk_16i_32fc_dot_prod_32fc_u_sse( lv_32fc_t* result, const short* input, const lv_32fc_t* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 8;
++-
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const short* aPtr = input;
++- const float* bPtr = (float*)taps;
++-
++- __m64 m0, m1;
++- __m128 f0, f1, f2, f3;
++- __m128 a0Val, a1Val, a2Val, a3Val;
++- __m128 b0Val, b1Val, b2Val, b3Val;
++- __m128 c0Val, c1Val, c2Val, c3Val;
++-
++- __m128 dotProdVal0 = _mm_setzero_ps();
++- __m128 dotProdVal1 = _mm_setzero_ps();
++- __m128 dotProdVal2 = _mm_setzero_ps();
++- __m128 dotProdVal3 = _mm_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- m0 = _mm_set_pi16(*(aPtr+3), *(aPtr+2), *(aPtr+1), *(aPtr+0));
++- m1 = _mm_set_pi16(*(aPtr+7), *(aPtr+6), *(aPtr+5), *(aPtr+4));
++- f0 = _mm_cvtpi16_ps(m0);
++- f1 = _mm_cvtpi16_ps(m0);
++- f2 = _mm_cvtpi16_ps(m1);
++- f3 = _mm_cvtpi16_ps(m1);
++-
++- a0Val = _mm_unpacklo_ps(f0, f1);
++- a1Val = _mm_unpackhi_ps(f0, f1);
++- a2Val = _mm_unpacklo_ps(f2, f3);
++- a3Val = _mm_unpackhi_ps(f2, f3);
++-
++- b0Val = _mm_loadu_ps(bPtr);
++- b1Val = _mm_loadu_ps(bPtr+4);
++- b2Val = _mm_loadu_ps(bPtr+8);
++- b3Val = _mm_loadu_ps(bPtr+12);
++-
++- c0Val = _mm_mul_ps(a0Val, b0Val);
++- c1Val = _mm_mul_ps(a1Val, b1Val);
++- c2Val = _mm_mul_ps(a2Val, b2Val);
++- c3Val = _mm_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
++-
++- aPtr += 8;
++- bPtr += 16;
++- }
++-
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
++-
++- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- *realpt = dotProductVector[0];
++- *imagpt = dotProductVector[1];
++- *realpt += dotProductVector[2];
++- *imagpt += dotProductVector[3];
++-
++- number = sixteenthPoints*8;
++- for(;number < num_points; number++){
++- *realpt += ((*aPtr) * (*bPtr++));
++- *imagpt += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = *(lv_32fc_t*)(&res[0]);
+++static inline void volk_16i_32fc_dot_prod_32fc_u_sse(lv_32fc_t* result,
+++ const short* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 8;
+++
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const short* aPtr = input;
+++ const float* bPtr = (float*)taps;
+++
+++ __m64 m0, m1;
+++ __m128 f0, f1, f2, f3;
+++ __m128 a0Val, a1Val, a2Val, a3Val;
+++ __m128 b0Val, b1Val, b2Val, b3Val;
+++ __m128 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m128 dotProdVal0 = _mm_setzero_ps();
+++ __m128 dotProdVal1 = _mm_setzero_ps();
+++ __m128 dotProdVal2 = _mm_setzero_ps();
+++ __m128 dotProdVal3 = _mm_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ m0 = _mm_set_pi16(*(aPtr + 3), *(aPtr + 2), *(aPtr + 1), *(aPtr + 0));
+++ m1 = _mm_set_pi16(*(aPtr + 7), *(aPtr + 6), *(aPtr + 5), *(aPtr + 4));
+++ f0 = _mm_cvtpi16_ps(m0);
+++ f1 = _mm_cvtpi16_ps(m0);
+++ f2 = _mm_cvtpi16_ps(m1);
+++ f3 = _mm_cvtpi16_ps(m1);
+++
+++ a0Val = _mm_unpacklo_ps(f0, f1);
+++ a1Val = _mm_unpackhi_ps(f0, f1);
+++ a2Val = _mm_unpacklo_ps(f2, f3);
+++ a3Val = _mm_unpackhi_ps(f2, f3);
+++
+++ b0Val = _mm_loadu_ps(bPtr);
+++ b1Val = _mm_loadu_ps(bPtr + 4);
+++ b2Val = _mm_loadu_ps(bPtr + 8);
+++ b3Val = _mm_loadu_ps(bPtr + 12);
+++
+++ c0Val = _mm_mul_ps(a0Val, b0Val);
+++ c1Val = _mm_mul_ps(a1Val, b1Val);
+++ c2Val = _mm_mul_ps(a2Val, b2Val);
+++ c3Val = _mm_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
+++
+++ aPtr += 8;
+++ bPtr += 16;
+++ }
+++
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
+++
+++ _mm_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ *realpt = dotProductVector[0];
+++ *imagpt = dotProductVector[1];
+++ *realpt += dotProductVector[2];
+++ *imagpt += dotProductVector[3];
+++
+++ number = sixteenthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *realpt += ((*aPtr) * (*bPtr++));
+++ *imagpt += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++ #endif /*LV_HAVE_SSE && LV_HAVE_MMX*/
++@@ -224,85 +237,90 @@ static inline void volk_16i_32fc_dot_prod_32fc_u_sse( lv_32fc_t* result, const
++
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++
++-static inline void volk_16i_32fc_dot_prod_32fc_u_avx2_fma( lv_32fc_t* result, const short* input, const lv_32fc_t* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const short* aPtr = input;
++- const float* bPtr = (float*)taps;
++-
++- __m128i m0, m1;
++- __m256i f0, f1;
++- __m256 g0, g1, h0, h1, h2, h3;
++- __m256 a0Val, a1Val, a2Val, a3Val;
++- __m256 b0Val, b1Val, b2Val, b3Val;
++-
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
++- __m256 dotProdVal2 = _mm256_setzero_ps();
++- __m256 dotProdVal3 = _mm256_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- m0 = _mm_loadu_si128((__m128i const*) aPtr);
++- m1 = _mm_loadu_si128((__m128i const*)(aPtr+8));
++-
++- f0 = _mm256_cvtepi16_epi32(m0);
++- g0 = _mm256_cvtepi32_ps(f0);
++- f1 = _mm256_cvtepi16_epi32(m1);
++- g1 = _mm256_cvtepi32_ps(f1);
++-
++- h0 = _mm256_unpacklo_ps(g0, g0);
++- h1 = _mm256_unpackhi_ps(g0, g0);
++- h2 = _mm256_unpacklo_ps(g1, g1);
++- h3 = _mm256_unpackhi_ps(g1, g1);
++-
++- a0Val = _mm256_permute2f128_ps(h0, h1, 0x20);
++- a1Val = _mm256_permute2f128_ps(h0, h1, 0x31);
++- a2Val = _mm256_permute2f128_ps(h2, h3, 0x20);
++- a3Val = _mm256_permute2f128_ps(h2, h3, 0x31);
++-
++- b0Val = _mm256_loadu_ps(bPtr);
++- b1Val = _mm256_loadu_ps(bPtr+8);
++- b2Val = _mm256_loadu_ps(bPtr+16);
++- b3Val = _mm256_loadu_ps(bPtr+24);
++-
++- dotProdVal0 = _mm256_fmadd_ps(a0Val,b0Val,dotProdVal0);
++- dotProdVal1 = _mm256_fmadd_ps(a1Val,b1Val,dotProdVal1);
++- dotProdVal2 = _mm256_fmadd_ps(a2Val,b2Val,dotProdVal2);
++- dotProdVal3 = _mm256_fmadd_ps(a3Val,b3Val,dotProdVal3);
++-
++- aPtr += 16;
++- bPtr += 32;
++- }
++-
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++-
++- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- *realpt = dotProductVector[0];
++- *imagpt = dotProductVector[1];
++- *realpt += dotProductVector[2];
++- *imagpt += dotProductVector[3];
++- *realpt += dotProductVector[4];
++- *imagpt += dotProductVector[5];
++- *realpt += dotProductVector[6];
++- *imagpt += dotProductVector[7];
++-
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- *realpt += ((*aPtr) * (*bPtr++));
++- *imagpt += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = *(lv_32fc_t*)(&res[0]);
+++static inline void volk_16i_32fc_dot_prod_32fc_u_avx2_fma(lv_32fc_t* result,
+++ const short* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const short* aPtr = input;
+++ const float* bPtr = (float*)taps;
+++
+++ __m128i m0, m1;
+++ __m256i f0, f1;
+++ __m256 g0, g1, h0, h1, h2, h3;
+++ __m256 a0Val, a1Val, a2Val, a3Val;
+++ __m256 b0Val, b1Val, b2Val, b3Val;
+++
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 dotProdVal2 = _mm256_setzero_ps();
+++ __m256 dotProdVal3 = _mm256_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ m0 = _mm_loadu_si128((__m128i const*)aPtr);
+++ m1 = _mm_loadu_si128((__m128i const*)(aPtr + 8));
+++
+++ f0 = _mm256_cvtepi16_epi32(m0);
+++ g0 = _mm256_cvtepi32_ps(f0);
+++ f1 = _mm256_cvtepi16_epi32(m1);
+++ g1 = _mm256_cvtepi32_ps(f1);
+++
+++ h0 = _mm256_unpacklo_ps(g0, g0);
+++ h1 = _mm256_unpackhi_ps(g0, g0);
+++ h2 = _mm256_unpacklo_ps(g1, g1);
+++ h3 = _mm256_unpackhi_ps(g1, g1);
+++
+++ a0Val = _mm256_permute2f128_ps(h0, h1, 0x20);
+++ a1Val = _mm256_permute2f128_ps(h0, h1, 0x31);
+++ a2Val = _mm256_permute2f128_ps(h2, h3, 0x20);
+++ a3Val = _mm256_permute2f128_ps(h2, h3, 0x31);
+++
+++ b0Val = _mm256_loadu_ps(bPtr);
+++ b1Val = _mm256_loadu_ps(bPtr + 8);
+++ b2Val = _mm256_loadu_ps(bPtr + 16);
+++ b3Val = _mm256_loadu_ps(bPtr + 24);
+++
+++ dotProdVal0 = _mm256_fmadd_ps(a0Val, b0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_fmadd_ps(a1Val, b1Val, dotProdVal1);
+++ dotProdVal2 = _mm256_fmadd_ps(a2Val, b2Val, dotProdVal2);
+++ dotProdVal3 = _mm256_fmadd_ps(a3Val, b3Val, dotProdVal3);
+++
+++ aPtr += 16;
+++ bPtr += 32;
+++ }
+++
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ *realpt = dotProductVector[0];
+++ *imagpt = dotProductVector[1];
+++ *realpt += dotProductVector[2];
+++ *imagpt += dotProductVector[3];
+++ *realpt += dotProductVector[4];
+++ *imagpt += dotProductVector[5];
+++ *realpt += dotProductVector[6];
+++ *imagpt += dotProductVector[7];
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *realpt += ((*aPtr) * (*bPtr++));
+++ *imagpt += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++ #endif /*LV_HAVE_AVX2 && lV_HAVE_FMA*/
++@@ -310,91 +328,96 @@ static inline void volk_16i_32fc_dot_prod_32fc_u_avx2_fma( lv_32fc_t* result, co
++
++ #ifdef LV_HAVE_AVX2
++
++-static inline void volk_16i_32fc_dot_prod_32fc_u_avx2( lv_32fc_t* result, const short* input, const lv_32fc_t* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const short* aPtr = input;
++- const float* bPtr = (float*)taps;
++-
++- __m128i m0, m1;
++- __m256i f0, f1;
++- __m256 g0, g1, h0, h1, h2, h3;
++- __m256 a0Val, a1Val, a2Val, a3Val;
++- __m256 b0Val, b1Val, b2Val, b3Val;
++- __m256 c0Val, c1Val, c2Val, c3Val;
++-
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
++- __m256 dotProdVal2 = _mm256_setzero_ps();
++- __m256 dotProdVal3 = _mm256_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- m0 = _mm_loadu_si128((__m128i const*) aPtr);
++- m1 = _mm_loadu_si128((__m128i const*)(aPtr+8));
++-
++- f0 = _mm256_cvtepi16_epi32(m0);
++- g0 = _mm256_cvtepi32_ps(f0);
++- f1 = _mm256_cvtepi16_epi32(m1);
++- g1 = _mm256_cvtepi32_ps(f1);
++-
++- h0 = _mm256_unpacklo_ps(g0, g0);
++- h1 = _mm256_unpackhi_ps(g0, g0);
++- h2 = _mm256_unpacklo_ps(g1, g1);
++- h3 = _mm256_unpackhi_ps(g1, g1);
++-
++- a0Val = _mm256_permute2f128_ps(h0, h1, 0x20);
++- a1Val = _mm256_permute2f128_ps(h0, h1, 0x31);
++- a2Val = _mm256_permute2f128_ps(h2, h3, 0x20);
++- a3Val = _mm256_permute2f128_ps(h2, h3, 0x31);
++-
++- b0Val = _mm256_loadu_ps(bPtr);
++- b1Val = _mm256_loadu_ps(bPtr+8);
++- b2Val = _mm256_loadu_ps(bPtr+16);
++- b3Val = _mm256_loadu_ps(bPtr+24);
++-
++- c0Val = _mm256_mul_ps(a0Val, b0Val);
++- c1Val = _mm256_mul_ps(a1Val, b1Val);
++- c2Val = _mm256_mul_ps(a2Val, b2Val);
++- c3Val = _mm256_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm256_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm256_add_ps(c3Val, dotProdVal3);
++-
++- aPtr += 16;
++- bPtr += 32;
++- }
++-
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++-
++- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- *realpt = dotProductVector[0];
++- *imagpt = dotProductVector[1];
++- *realpt += dotProductVector[2];
++- *imagpt += dotProductVector[3];
++- *realpt += dotProductVector[4];
++- *imagpt += dotProductVector[5];
++- *realpt += dotProductVector[6];
++- *imagpt += dotProductVector[7];
++-
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- *realpt += ((*aPtr) * (*bPtr++));
++- *imagpt += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = *(lv_32fc_t*)(&res[0]);
+++static inline void volk_16i_32fc_dot_prod_32fc_u_avx2(lv_32fc_t* result,
+++ const short* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const short* aPtr = input;
+++ const float* bPtr = (float*)taps;
+++
+++ __m128i m0, m1;
+++ __m256i f0, f1;
+++ __m256 g0, g1, h0, h1, h2, h3;
+++ __m256 a0Val, a1Val, a2Val, a3Val;
+++ __m256 b0Val, b1Val, b2Val, b3Val;
+++ __m256 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 dotProdVal2 = _mm256_setzero_ps();
+++ __m256 dotProdVal3 = _mm256_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ m0 = _mm_loadu_si128((__m128i const*)aPtr);
+++ m1 = _mm_loadu_si128((__m128i const*)(aPtr + 8));
+++
+++ f0 = _mm256_cvtepi16_epi32(m0);
+++ g0 = _mm256_cvtepi32_ps(f0);
+++ f1 = _mm256_cvtepi16_epi32(m1);
+++ g1 = _mm256_cvtepi32_ps(f1);
+++
+++ h0 = _mm256_unpacklo_ps(g0, g0);
+++ h1 = _mm256_unpackhi_ps(g0, g0);
+++ h2 = _mm256_unpacklo_ps(g1, g1);
+++ h3 = _mm256_unpackhi_ps(g1, g1);
+++
+++ a0Val = _mm256_permute2f128_ps(h0, h1, 0x20);
+++ a1Val = _mm256_permute2f128_ps(h0, h1, 0x31);
+++ a2Val = _mm256_permute2f128_ps(h2, h3, 0x20);
+++ a3Val = _mm256_permute2f128_ps(h2, h3, 0x31);
+++
+++ b0Val = _mm256_loadu_ps(bPtr);
+++ b1Val = _mm256_loadu_ps(bPtr + 8);
+++ b2Val = _mm256_loadu_ps(bPtr + 16);
+++ b3Val = _mm256_loadu_ps(bPtr + 24);
+++
+++ c0Val = _mm256_mul_ps(a0Val, b0Val);
+++ c1Val = _mm256_mul_ps(a1Val, b1Val);
+++ c2Val = _mm256_mul_ps(a2Val, b2Val);
+++ c3Val = _mm256_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm256_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm256_add_ps(c3Val, dotProdVal3);
+++
+++ aPtr += 16;
+++ bPtr += 32;
+++ }
+++
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ *realpt = dotProductVector[0];
+++ *imagpt = dotProductVector[1];
+++ *realpt += dotProductVector[2];
+++ *imagpt += dotProductVector[3];
+++ *realpt += dotProductVector[4];
+++ *imagpt += dotProductVector[5];
+++ *realpt += dotProductVector[6];
+++ *imagpt += dotProductVector[7];
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *realpt += ((*aPtr) * (*bPtr++));
+++ *imagpt += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++ #endif /*LV_HAVE_AVX2*/
++@@ -403,171 +426,181 @@ static inline void volk_16i_32fc_dot_prod_32fc_u_avx2( lv_32fc_t* result, const
++ #if LV_HAVE_SSE && LV_HAVE_MMX
++
++
++-static inline void volk_16i_32fc_dot_prod_32fc_a_sse( lv_32fc_t* result, const short* input, const lv_32fc_t* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 8;
++-
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const short* aPtr = input;
++- const float* bPtr = (float*)taps;
++-
++- __m64 m0, m1;
++- __m128 f0, f1, f2, f3;
++- __m128 a0Val, a1Val, a2Val, a3Val;
++- __m128 b0Val, b1Val, b2Val, b3Val;
++- __m128 c0Val, c1Val, c2Val, c3Val;
++-
++- __m128 dotProdVal0 = _mm_setzero_ps();
++- __m128 dotProdVal1 = _mm_setzero_ps();
++- __m128 dotProdVal2 = _mm_setzero_ps();
++- __m128 dotProdVal3 = _mm_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- m0 = _mm_set_pi16(*(aPtr+3), *(aPtr+2), *(aPtr+1), *(aPtr+0));
++- m1 = _mm_set_pi16(*(aPtr+7), *(aPtr+6), *(aPtr+5), *(aPtr+4));
++- f0 = _mm_cvtpi16_ps(m0);
++- f1 = _mm_cvtpi16_ps(m0);
++- f2 = _mm_cvtpi16_ps(m1);
++- f3 = _mm_cvtpi16_ps(m1);
++-
++- a0Val = _mm_unpacklo_ps(f0, f1);
++- a1Val = _mm_unpackhi_ps(f0, f1);
++- a2Val = _mm_unpacklo_ps(f2, f3);
++- a3Val = _mm_unpackhi_ps(f2, f3);
++-
++- b0Val = _mm_load_ps(bPtr);
++- b1Val = _mm_load_ps(bPtr+4);
++- b2Val = _mm_load_ps(bPtr+8);
++- b3Val = _mm_load_ps(bPtr+12);
++-
++- c0Val = _mm_mul_ps(a0Val, b0Val);
++- c1Val = _mm_mul_ps(a1Val, b1Val);
++- c2Val = _mm_mul_ps(a2Val, b2Val);
++- c3Val = _mm_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
++-
++- aPtr += 8;
++- bPtr += 16;
++- }
++-
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
++-
++- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- *realpt = dotProductVector[0];
++- *imagpt = dotProductVector[1];
++- *realpt += dotProductVector[2];
++- *imagpt += dotProductVector[3];
++-
++- number = sixteenthPoints*8;
++- for(;number < num_points; number++){
++- *realpt += ((*aPtr) * (*bPtr++));
++- *imagpt += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = *(lv_32fc_t*)(&res[0]);
+++static inline void volk_16i_32fc_dot_prod_32fc_a_sse(lv_32fc_t* result,
+++ const short* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 8;
+++
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const short* aPtr = input;
+++ const float* bPtr = (float*)taps;
+++
+++ __m64 m0, m1;
+++ __m128 f0, f1, f2, f3;
+++ __m128 a0Val, a1Val, a2Val, a3Val;
+++ __m128 b0Val, b1Val, b2Val, b3Val;
+++ __m128 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m128 dotProdVal0 = _mm_setzero_ps();
+++ __m128 dotProdVal1 = _mm_setzero_ps();
+++ __m128 dotProdVal2 = _mm_setzero_ps();
+++ __m128 dotProdVal3 = _mm_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ m0 = _mm_set_pi16(*(aPtr + 3), *(aPtr + 2), *(aPtr + 1), *(aPtr + 0));
+++ m1 = _mm_set_pi16(*(aPtr + 7), *(aPtr + 6), *(aPtr + 5), *(aPtr + 4));
+++ f0 = _mm_cvtpi16_ps(m0);
+++ f1 = _mm_cvtpi16_ps(m0);
+++ f2 = _mm_cvtpi16_ps(m1);
+++ f3 = _mm_cvtpi16_ps(m1);
+++
+++ a0Val = _mm_unpacklo_ps(f0, f1);
+++ a1Val = _mm_unpackhi_ps(f0, f1);
+++ a2Val = _mm_unpacklo_ps(f2, f3);
+++ a3Val = _mm_unpackhi_ps(f2, f3);
+++
+++ b0Val = _mm_load_ps(bPtr);
+++ b1Val = _mm_load_ps(bPtr + 4);
+++ b2Val = _mm_load_ps(bPtr + 8);
+++ b3Val = _mm_load_ps(bPtr + 12);
+++
+++ c0Val = _mm_mul_ps(a0Val, b0Val);
+++ c1Val = _mm_mul_ps(a1Val, b1Val);
+++ c2Val = _mm_mul_ps(a2Val, b2Val);
+++ c3Val = _mm_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
+++
+++ aPtr += 8;
+++ bPtr += 16;
+++ }
+++
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
+++
+++ _mm_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ *realpt = dotProductVector[0];
+++ *imagpt = dotProductVector[1];
+++ *realpt += dotProductVector[2];
+++ *imagpt += dotProductVector[3];
+++
+++ number = sixteenthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *realpt += ((*aPtr) * (*bPtr++));
+++ *imagpt += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++ #endif /*LV_HAVE_SSE && LV_HAVE_MMX*/
++
++ #ifdef LV_HAVE_AVX2
++
++-static inline void volk_16i_32fc_dot_prod_32fc_a_avx2( lv_32fc_t* result, const short* input, const lv_32fc_t* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const short* aPtr = input;
++- const float* bPtr = (float*)taps;
++-
++- __m128i m0, m1;
++- __m256i f0, f1;
++- __m256 g0, g1, h0, h1, h2, h3;
++- __m256 a0Val, a1Val, a2Val, a3Val;
++- __m256 b0Val, b1Val, b2Val, b3Val;
++- __m256 c0Val, c1Val, c2Val, c3Val;
++-
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
++- __m256 dotProdVal2 = _mm256_setzero_ps();
++- __m256 dotProdVal3 = _mm256_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- m0 = _mm_load_si128((__m128i const*) aPtr);
++- m1 = _mm_load_si128((__m128i const*)(aPtr+8));
++-
++- f0 = _mm256_cvtepi16_epi32(m0);
++- g0 = _mm256_cvtepi32_ps(f0);
++- f1 = _mm256_cvtepi16_epi32(m1);
++- g1 = _mm256_cvtepi32_ps(f1);
++-
++- h0 = _mm256_unpacklo_ps(g0, g0);
++- h1 = _mm256_unpackhi_ps(g0, g0);
++- h2 = _mm256_unpacklo_ps(g1, g1);
++- h3 = _mm256_unpackhi_ps(g1, g1);
++-
++- a0Val = _mm256_permute2f128_ps(h0, h1, 0x20);
++- a1Val = _mm256_permute2f128_ps(h0, h1, 0x31);
++- a2Val = _mm256_permute2f128_ps(h2, h3, 0x20);
++- a3Val = _mm256_permute2f128_ps(h2, h3, 0x31);
++-
++- b0Val = _mm256_load_ps(bPtr);
++- b1Val = _mm256_load_ps(bPtr+8);
++- b2Val = _mm256_load_ps(bPtr+16);
++- b3Val = _mm256_load_ps(bPtr+24);
++-
++- c0Val = _mm256_mul_ps(a0Val, b0Val);
++- c1Val = _mm256_mul_ps(a1Val, b1Val);
++- c2Val = _mm256_mul_ps(a2Val, b2Val);
++- c3Val = _mm256_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm256_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm256_add_ps(c3Val, dotProdVal3);
++-
++- aPtr += 16;
++- bPtr += 32;
++- }
++-
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++-
++- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- *realpt = dotProductVector[0];
++- *imagpt = dotProductVector[1];
++- *realpt += dotProductVector[2];
++- *imagpt += dotProductVector[3];
++- *realpt += dotProductVector[4];
++- *imagpt += dotProductVector[5];
++- *realpt += dotProductVector[6];
++- *imagpt += dotProductVector[7];
++-
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- *realpt += ((*aPtr) * (*bPtr++));
++- *imagpt += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = *(lv_32fc_t*)(&res[0]);
+++static inline void volk_16i_32fc_dot_prod_32fc_a_avx2(lv_32fc_t* result,
+++ const short* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const short* aPtr = input;
+++ const float* bPtr = (float*)taps;
+++
+++ __m128i m0, m1;
+++ __m256i f0, f1;
+++ __m256 g0, g1, h0, h1, h2, h3;
+++ __m256 a0Val, a1Val, a2Val, a3Val;
+++ __m256 b0Val, b1Val, b2Val, b3Val;
+++ __m256 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 dotProdVal2 = _mm256_setzero_ps();
+++ __m256 dotProdVal3 = _mm256_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ m0 = _mm_load_si128((__m128i const*)aPtr);
+++ m1 = _mm_load_si128((__m128i const*)(aPtr + 8));
+++
+++ f0 = _mm256_cvtepi16_epi32(m0);
+++ g0 = _mm256_cvtepi32_ps(f0);
+++ f1 = _mm256_cvtepi16_epi32(m1);
+++ g1 = _mm256_cvtepi32_ps(f1);
+++
+++ h0 = _mm256_unpacklo_ps(g0, g0);
+++ h1 = _mm256_unpackhi_ps(g0, g0);
+++ h2 = _mm256_unpacklo_ps(g1, g1);
+++ h3 = _mm256_unpackhi_ps(g1, g1);
+++
+++ a0Val = _mm256_permute2f128_ps(h0, h1, 0x20);
+++ a1Val = _mm256_permute2f128_ps(h0, h1, 0x31);
+++ a2Val = _mm256_permute2f128_ps(h2, h3, 0x20);
+++ a3Val = _mm256_permute2f128_ps(h2, h3, 0x31);
+++
+++ b0Val = _mm256_load_ps(bPtr);
+++ b1Val = _mm256_load_ps(bPtr + 8);
+++ b2Val = _mm256_load_ps(bPtr + 16);
+++ b3Val = _mm256_load_ps(bPtr + 24);
+++
+++ c0Val = _mm256_mul_ps(a0Val, b0Val);
+++ c1Val = _mm256_mul_ps(a1Val, b1Val);
+++ c2Val = _mm256_mul_ps(a2Val, b2Val);
+++ c3Val = _mm256_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm256_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm256_add_ps(c3Val, dotProdVal3);
+++
+++ aPtr += 16;
+++ bPtr += 32;
+++ }
+++
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ *realpt = dotProductVector[0];
+++ *imagpt = dotProductVector[1];
+++ *realpt += dotProductVector[2];
+++ *imagpt += dotProductVector[3];
+++ *realpt += dotProductVector[4];
+++ *imagpt += dotProductVector[5];
+++ *realpt += dotProductVector[6];
+++ *imagpt += dotProductVector[7];
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *realpt += ((*aPtr) * (*bPtr++));
+++ *imagpt += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++
++@@ -575,85 +608,90 @@ static inline void volk_16i_32fc_dot_prod_32fc_a_avx2( lv_32fc_t* result, const
++
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++
++-static inline void volk_16i_32fc_dot_prod_32fc_a_avx2_fma( lv_32fc_t* result, const short* input, const lv_32fc_t* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const short* aPtr = input;
++- const float* bPtr = (float*)taps;
++-
++- __m128i m0, m1;
++- __m256i f0, f1;
++- __m256 g0, g1, h0, h1, h2, h3;
++- __m256 a0Val, a1Val, a2Val, a3Val;
++- __m256 b0Val, b1Val, b2Val, b3Val;
++-
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
++- __m256 dotProdVal2 = _mm256_setzero_ps();
++- __m256 dotProdVal3 = _mm256_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- m0 = _mm_load_si128((__m128i const*) aPtr);
++- m1 = _mm_load_si128((__m128i const*)(aPtr+8));
++-
++- f0 = _mm256_cvtepi16_epi32(m0);
++- g0 = _mm256_cvtepi32_ps(f0);
++- f1 = _mm256_cvtepi16_epi32(m1);
++- g1 = _mm256_cvtepi32_ps(f1);
++-
++- h0 = _mm256_unpacklo_ps(g0, g0);
++- h1 = _mm256_unpackhi_ps(g0, g0);
++- h2 = _mm256_unpacklo_ps(g1, g1);
++- h3 = _mm256_unpackhi_ps(g1, g1);
++-
++- a0Val = _mm256_permute2f128_ps(h0, h1, 0x20);
++- a1Val = _mm256_permute2f128_ps(h0, h1, 0x31);
++- a2Val = _mm256_permute2f128_ps(h2, h3, 0x20);
++- a3Val = _mm256_permute2f128_ps(h2, h3, 0x31);
++-
++- b0Val = _mm256_load_ps(bPtr);
++- b1Val = _mm256_load_ps(bPtr+8);
++- b2Val = _mm256_load_ps(bPtr+16);
++- b3Val = _mm256_load_ps(bPtr+24);
++-
++- dotProdVal0 = _mm256_fmadd_ps(a0Val,b0Val,dotProdVal0);
++- dotProdVal1 = _mm256_fmadd_ps(a1Val,b1Val,dotProdVal1);
++- dotProdVal2 = _mm256_fmadd_ps(a2Val,b2Val,dotProdVal2);
++- dotProdVal3 = _mm256_fmadd_ps(a3Val,b3Val,dotProdVal3);
++-
++- aPtr += 16;
++- bPtr += 32;
++- }
++-
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++-
++- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- *realpt = dotProductVector[0];
++- *imagpt = dotProductVector[1];
++- *realpt += dotProductVector[2];
++- *imagpt += dotProductVector[3];
++- *realpt += dotProductVector[4];
++- *imagpt += dotProductVector[5];
++- *realpt += dotProductVector[6];
++- *imagpt += dotProductVector[7];
++-
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- *realpt += ((*aPtr) * (*bPtr++));
++- *imagpt += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = *(lv_32fc_t*)(&res[0]);
+++static inline void volk_16i_32fc_dot_prod_32fc_a_avx2_fma(lv_32fc_t* result,
+++ const short* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const short* aPtr = input;
+++ const float* bPtr = (float*)taps;
+++
+++ __m128i m0, m1;
+++ __m256i f0, f1;
+++ __m256 g0, g1, h0, h1, h2, h3;
+++ __m256 a0Val, a1Val, a2Val, a3Val;
+++ __m256 b0Val, b1Val, b2Val, b3Val;
+++
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 dotProdVal2 = _mm256_setzero_ps();
+++ __m256 dotProdVal3 = _mm256_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ m0 = _mm_load_si128((__m128i const*)aPtr);
+++ m1 = _mm_load_si128((__m128i const*)(aPtr + 8));
+++
+++ f0 = _mm256_cvtepi16_epi32(m0);
+++ g0 = _mm256_cvtepi32_ps(f0);
+++ f1 = _mm256_cvtepi16_epi32(m1);
+++ g1 = _mm256_cvtepi32_ps(f1);
+++
+++ h0 = _mm256_unpacklo_ps(g0, g0);
+++ h1 = _mm256_unpackhi_ps(g0, g0);
+++ h2 = _mm256_unpacklo_ps(g1, g1);
+++ h3 = _mm256_unpackhi_ps(g1, g1);
+++
+++ a0Val = _mm256_permute2f128_ps(h0, h1, 0x20);
+++ a1Val = _mm256_permute2f128_ps(h0, h1, 0x31);
+++ a2Val = _mm256_permute2f128_ps(h2, h3, 0x20);
+++ a3Val = _mm256_permute2f128_ps(h2, h3, 0x31);
+++
+++ b0Val = _mm256_load_ps(bPtr);
+++ b1Val = _mm256_load_ps(bPtr + 8);
+++ b2Val = _mm256_load_ps(bPtr + 16);
+++ b3Val = _mm256_load_ps(bPtr + 24);
+++
+++ dotProdVal0 = _mm256_fmadd_ps(a0Val, b0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_fmadd_ps(a1Val, b1Val, dotProdVal1);
+++ dotProdVal2 = _mm256_fmadd_ps(a2Val, b2Val, dotProdVal2);
+++ dotProdVal3 = _mm256_fmadd_ps(a3Val, b3Val, dotProdVal3);
+++
+++ aPtr += 16;
+++ bPtr += 32;
+++ }
+++
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ *realpt = dotProductVector[0];
+++ *imagpt = dotProductVector[1];
+++ *realpt += dotProductVector[2];
+++ *imagpt += dotProductVector[3];
+++ *realpt += dotProductVector[4];
+++ *imagpt += dotProductVector[5];
+++ *realpt += dotProductVector[6];
+++ *imagpt += dotProductVector[7];
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *realpt += ((*aPtr) * (*bPtr++));
+++ *imagpt += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++
++diff --git a/kernels/volk/volk_16i_branch_4_state_8.h b/kernels/volk/volk_16i_branch_4_state_8.h
++index 31b66cc..4d00b6b 100644
++--- a/kernels/volk/volk_16i_branch_4_state_8.h
+++++ b/kernels/volk/volk_16i_branch_4_state_8.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16i_branch_4_state_8(short* target, short* src0, char** permuters, short* cntl2, short* cntl3, short* scalars)
++- * \endcode
+++ * void volk_16i_branch_4_state_8(short* target, short* src0, char** permuters, short*
+++ * cntl2, short* cntl3, short* scalars) \endcode
++ *
++ * \b Inputs
++ * \li src0: <FIXME>
++@@ -61,155 +61,154 @@
++
++ #ifdef LV_HAVE_SSSE3
++
++-#include <xmmintrin.h>
++ #include <emmintrin.h>
++ #include <tmmintrin.h>
+++#include <xmmintrin.h>
++
++-static inline void
++-volk_16i_branch_4_state_8_a_ssse3(short* target, short* src0, char** permuters, short* cntl2, short* cntl3, short* scalars)
+++static inline void volk_16i_branch_4_state_8_a_ssse3(short* target,
+++ short* src0,
+++ char** permuters,
+++ short* cntl2,
+++ short* cntl3,
+++ short* scalars)
++ {
++- __m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11;
++- __m128i *p_target, *p_src0, *p_cntl2, *p_cntl3, *p_scalars;
+++ __m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11;
+++ __m128i *p_target, *p_src0, *p_cntl2, *p_cntl3, *p_scalars;
++
++- p_target = (__m128i*)target;
++- p_src0 = (__m128i*)src0;
++- p_cntl2 = (__m128i*)cntl2;
++- p_cntl3 = (__m128i*)cntl3;
++- p_scalars = (__m128i*)scalars;
+++ p_target = (__m128i*)target;
+++ p_src0 = (__m128i*)src0;
+++ p_cntl2 = (__m128i*)cntl2;
+++ p_cntl3 = (__m128i*)cntl3;
+++ p_scalars = (__m128i*)scalars;
++
++- xmm0 = _mm_load_si128(p_scalars);
+++ xmm0 = _mm_load_si128(p_scalars);
++
++- xmm1 = _mm_shufflelo_epi16(xmm0, 0);
++- xmm2 = _mm_shufflelo_epi16(xmm0, 0x55);
++- xmm3 = _mm_shufflelo_epi16(xmm0, 0xaa);
++- xmm4 = _mm_shufflelo_epi16(xmm0, 0xff);
+++ xmm1 = _mm_shufflelo_epi16(xmm0, 0);
+++ xmm2 = _mm_shufflelo_epi16(xmm0, 0x55);
+++ xmm3 = _mm_shufflelo_epi16(xmm0, 0xaa);
+++ xmm4 = _mm_shufflelo_epi16(xmm0, 0xff);
++
++- xmm1 = _mm_shuffle_epi32(xmm1, 0x00);
++- xmm2 = _mm_shuffle_epi32(xmm2, 0x00);
++- xmm3 = _mm_shuffle_epi32(xmm3, 0x00);
++- xmm4 = _mm_shuffle_epi32(xmm4, 0x00);
+++ xmm1 = _mm_shuffle_epi32(xmm1, 0x00);
+++ xmm2 = _mm_shuffle_epi32(xmm2, 0x00);
+++ xmm3 = _mm_shuffle_epi32(xmm3, 0x00);
+++ xmm4 = _mm_shuffle_epi32(xmm4, 0x00);
++
++- xmm0 = _mm_load_si128((__m128i*)permuters[0]);
++- xmm6 = _mm_load_si128((__m128i*)permuters[1]);
++- xmm8 = _mm_load_si128((__m128i*)permuters[2]);
++- xmm10 = _mm_load_si128((__m128i*)permuters[3]);
+++ xmm0 = _mm_load_si128((__m128i*)permuters[0]);
+++ xmm6 = _mm_load_si128((__m128i*)permuters[1]);
+++ xmm8 = _mm_load_si128((__m128i*)permuters[2]);
+++ xmm10 = _mm_load_si128((__m128i*)permuters[3]);
++
++- xmm5 = _mm_load_si128(p_src0);
++- xmm0 = _mm_shuffle_epi8(xmm5, xmm0);
++- xmm6 = _mm_shuffle_epi8(xmm5, xmm6);
++- xmm8 = _mm_shuffle_epi8(xmm5, xmm8);
++- xmm10 = _mm_shuffle_epi8(xmm5, xmm10);
+++ xmm5 = _mm_load_si128(p_src0);
+++ xmm0 = _mm_shuffle_epi8(xmm5, xmm0);
+++ xmm6 = _mm_shuffle_epi8(xmm5, xmm6);
+++ xmm8 = _mm_shuffle_epi8(xmm5, xmm8);
+++ xmm10 = _mm_shuffle_epi8(xmm5, xmm10);
++
++- xmm5 = _mm_add_epi16(xmm1, xmm2);
+++ xmm5 = _mm_add_epi16(xmm1, xmm2);
++
++- xmm6 = _mm_add_epi16(xmm2, xmm6);
++- xmm8 = _mm_add_epi16(xmm1, xmm8);
+++ xmm6 = _mm_add_epi16(xmm2, xmm6);
+++ xmm8 = _mm_add_epi16(xmm1, xmm8);
++
++- xmm7 = _mm_load_si128(p_cntl2);
++- xmm9 = _mm_load_si128(p_cntl3);
+++ xmm7 = _mm_load_si128(p_cntl2);
+++ xmm9 = _mm_load_si128(p_cntl3);
++
++- xmm0 = _mm_add_epi16(xmm5, xmm0);
+++ xmm0 = _mm_add_epi16(xmm5, xmm0);
++
++- xmm7 = _mm_and_si128(xmm7, xmm3);
++- xmm9 = _mm_and_si128(xmm9, xmm4);
+++ xmm7 = _mm_and_si128(xmm7, xmm3);
+++ xmm9 = _mm_and_si128(xmm9, xmm4);
++
++- xmm5 = _mm_load_si128(&p_cntl2[1]);
++- xmm11 = _mm_load_si128(&p_cntl3[1]);
+++ xmm5 = _mm_load_si128(&p_cntl2[1]);
+++ xmm11 = _mm_load_si128(&p_cntl3[1]);
++
++- xmm7 = _mm_add_epi16(xmm7, xmm9);
+++ xmm7 = _mm_add_epi16(xmm7, xmm9);
++
++- xmm5 = _mm_and_si128(xmm5, xmm3);
++- xmm11 = _mm_and_si128(xmm11, xmm4);
+++ xmm5 = _mm_and_si128(xmm5, xmm3);
+++ xmm11 = _mm_and_si128(xmm11, xmm4);
++
++- xmm0 = _mm_add_epi16(xmm0, xmm7);
+++ xmm0 = _mm_add_epi16(xmm0, xmm7);
++
++
++- xmm7 = _mm_load_si128(&p_cntl2[2]);
++- xmm9 = _mm_load_si128(&p_cntl3[2]);
+++ xmm7 = _mm_load_si128(&p_cntl2[2]);
+++ xmm9 = _mm_load_si128(&p_cntl3[2]);
++
++- xmm5 = _mm_add_epi16(xmm5, xmm11);
+++ xmm5 = _mm_add_epi16(xmm5, xmm11);
++
++- xmm7 = _mm_and_si128(xmm7, xmm3);
++- xmm9 = _mm_and_si128(xmm9, xmm4);
+++ xmm7 = _mm_and_si128(xmm7, xmm3);
+++ xmm9 = _mm_and_si128(xmm9, xmm4);
++
++- xmm6 = _mm_add_epi16(xmm6, xmm5);
+++ xmm6 = _mm_add_epi16(xmm6, xmm5);
++
++
++- xmm5 = _mm_load_si128(&p_cntl2[3]);
++- xmm11 = _mm_load_si128(&p_cntl3[3]);
+++ xmm5 = _mm_load_si128(&p_cntl2[3]);
+++ xmm11 = _mm_load_si128(&p_cntl3[3]);
++
++- xmm7 = _mm_add_epi16(xmm7, xmm9);
+++ xmm7 = _mm_add_epi16(xmm7, xmm9);
++
++- xmm5 = _mm_and_si128(xmm5, xmm3);
++- xmm11 = _mm_and_si128(xmm11, xmm4);
+++ xmm5 = _mm_and_si128(xmm5, xmm3);
+++ xmm11 = _mm_and_si128(xmm11, xmm4);
++
++- xmm8 = _mm_add_epi16(xmm8, xmm7);
+++ xmm8 = _mm_add_epi16(xmm8, xmm7);
++
++- xmm5 = _mm_add_epi16(xmm5, xmm11);
+++ xmm5 = _mm_add_epi16(xmm5, xmm11);
++
++- _mm_store_si128(p_target, xmm0);
++- _mm_store_si128(&p_target[1], xmm6);
+++ _mm_store_si128(p_target, xmm0);
+++ _mm_store_si128(&p_target[1], xmm6);
++
++- xmm10 = _mm_add_epi16(xmm5, xmm10);
+++ xmm10 = _mm_add_epi16(xmm5, xmm10);
++
++- _mm_store_si128(&p_target[2], xmm8);
+++ _mm_store_si128(&p_target[2], xmm8);
++
++- _mm_store_si128(&p_target[3], xmm10);
+++ _mm_store_si128(&p_target[3], xmm10);
++ }
++
++
++ #endif /*LV_HAVE_SSEs*/
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void
++-volk_16i_branch_4_state_8_generic(short* target, short* src0, char** permuters, short* cntl2, short* cntl3, short* scalars)
+++static inline void volk_16i_branch_4_state_8_generic(short* target,
+++ short* src0,
+++ char** permuters,
+++ short* cntl2,
+++ short* cntl3,
+++ short* scalars)
++ {
++- int i = 0;
++-
++- int bound = 4;
++-
++- for(; i < bound; ++i) {
++- target[i* 8] = src0[((char)permuters[i][0])/2]
++- + ((i + 1)%2 * scalars[0])
++- + (((i >> 1)^1) * scalars[1])
++- + (cntl2[i * 8] & scalars[2])
++- + (cntl3[i * 8] & scalars[3]);
++- target[i* 8 + 1] = src0[((char)permuters[i][1 * 2])/2]
++- + ((i + 1)%2 * scalars[0])
++- + (((i >> 1)^1) * scalars[1])
++- + (cntl2[i * 8 + 1] & scalars[2])
++- + (cntl3[i * 8 + 1] & scalars[3]);
++- target[i* 8 + 2] = src0[((char)permuters[i][2 * 2])/2]
++- + ((i + 1)%2 * scalars[0])
++- + (((i >> 1)^1) * scalars[1])
++- + (cntl2[i * 8 + 2] & scalars[2])
++- + (cntl3[i * 8 + 2] & scalars[3]);
++- target[i* 8 + 3] = src0[((char)permuters[i][3 * 2])/2]
++- + ((i + 1)%2 * scalars[0])
++- + (((i >> 1)^1) * scalars[1])
++- + (cntl2[i * 8 + 3] & scalars[2])
++- + (cntl3[i * 8 + 3] & scalars[3]);
++- target[i* 8 + 4] = src0[((char)permuters[i][4 * 2])/2]
++- + ((i + 1)%2 * scalars[0])
++- + (((i >> 1)^1) * scalars[1])
++- + (cntl2[i * 8 + 4] & scalars[2])
++- + (cntl3[i * 8 + 4] & scalars[3]);
++- target[i* 8 + 5] = src0[((char)permuters[i][5 * 2])/2]
++- + ((i + 1)%2 * scalars[0])
++- + (((i >> 1)^1) * scalars[1])
++- + (cntl2[i * 8 + 5] & scalars[2])
++- + (cntl3[i * 8 + 5] & scalars[3]);
++- target[i* 8 + 6] = src0[((char)permuters[i][6 * 2])/2]
++- + ((i + 1)%2 * scalars[0])
++- + (((i >> 1)^1) * scalars[1])
++- + (cntl2[i * 8 + 6] & scalars[2])
++- + (cntl3[i * 8 + 6] & scalars[3]);
++- target[i* 8 + 7] = src0[((char)permuters[i][7 * 2])/2]
++- + ((i + 1)%2 * scalars[0])
++- + (((i >> 1)^1) * scalars[1])
++- + (cntl2[i * 8 + 7] & scalars[2])
++- + (cntl3[i * 8 + 7] & scalars[3]);
++- }
+++ int i = 0;
+++
+++ int bound = 4;
+++
+++ for (; i < bound; ++i) {
+++ target[i * 8] = src0[((char)permuters[i][0]) / 2] + ((i + 1) % 2 * scalars[0]) +
+++ (((i >> 1) ^ 1) * scalars[1]) + (cntl2[i * 8] & scalars[2]) +
+++ (cntl3[i * 8] & scalars[3]);
+++ target[i * 8 + 1] = src0[((char)permuters[i][1 * 2]) / 2] +
+++ ((i + 1) % 2 * scalars[0]) + (((i >> 1) ^ 1) * scalars[1]) +
+++ (cntl2[i * 8 + 1] & scalars[2]) +
+++ (cntl3[i * 8 + 1] & scalars[3]);
+++ target[i * 8 + 2] = src0[((char)permuters[i][2 * 2]) / 2] +
+++ ((i + 1) % 2 * scalars[0]) + (((i >> 1) ^ 1) * scalars[1]) +
+++ (cntl2[i * 8 + 2] & scalars[2]) +
+++ (cntl3[i * 8 + 2] & scalars[3]);
+++ target[i * 8 + 3] = src0[((char)permuters[i][3 * 2]) / 2] +
+++ ((i + 1) % 2 * scalars[0]) + (((i >> 1) ^ 1) * scalars[1]) +
+++ (cntl2[i * 8 + 3] & scalars[2]) +
+++ (cntl3[i * 8 + 3] & scalars[3]);
+++ target[i * 8 + 4] = src0[((char)permuters[i][4 * 2]) / 2] +
+++ ((i + 1) % 2 * scalars[0]) + (((i >> 1) ^ 1) * scalars[1]) +
+++ (cntl2[i * 8 + 4] & scalars[2]) +
+++ (cntl3[i * 8 + 4] & scalars[3]);
+++ target[i * 8 + 5] = src0[((char)permuters[i][5 * 2]) / 2] +
+++ ((i + 1) % 2 * scalars[0]) + (((i >> 1) ^ 1) * scalars[1]) +
+++ (cntl2[i * 8 + 5] & scalars[2]) +
+++ (cntl3[i * 8 + 5] & scalars[3]);
+++ target[i * 8 + 6] = src0[((char)permuters[i][6 * 2]) / 2] +
+++ ((i + 1) % 2 * scalars[0]) + (((i >> 1) ^ 1) * scalars[1]) +
+++ (cntl2[i * 8 + 6] & scalars[2]) +
+++ (cntl3[i * 8 + 6] & scalars[3]);
+++ target[i * 8 + 7] = src0[((char)permuters[i][7 * 2]) / 2] +
+++ ((i + 1) % 2 * scalars[0]) + (((i >> 1) ^ 1) * scalars[1]) +
+++ (cntl2[i * 8 + 7] & scalars[2]) +
+++ (cntl3[i * 8 + 7] & scalars[3]);
+++ }
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++diff --git a/kernels/volk/volk_16i_convert_8i.h b/kernels/volk/volk_16i_convert_8i.h
++index e2f953b..f09515d 100644
++--- a/kernels/volk/volk_16i_convert_8i.h
+++++ b/kernels/volk/volk_16i_convert_8i.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16i_convert_8i(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points)
++- * \endcode
+++ * void volk_16i_convert_8i(int8_t* outputVector, const int16_t* inputVector, unsigned int
+++ * num_points) \endcode
++ *
++ * \b Inputs
++ * \li inputVector: The input vector of 16-bit shorts.
++@@ -59,39 +59,42 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16i_convert_8i_u_avx2(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points)
+++static inline void volk_16i_convert_8i_u_avx2(int8_t* outputVector,
+++ const int16_t* inputVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int thirtysecondPoints = num_points / 32;
+++ unsigned int number = 0;
+++ const unsigned int thirtysecondPoints = num_points / 32;
++
++- int8_t* outputVectorPtr = outputVector;
++- int16_t* inputPtr = (int16_t*)inputVector;
++- __m256i inputVal1;
++- __m256i inputVal2;
++- __m256i ret;
+++ int8_t* outputVectorPtr = outputVector;
+++ int16_t* inputPtr = (int16_t*)inputVector;
+++ __m256i inputVal1;
+++ __m256i inputVal2;
+++ __m256i ret;
++
++- for(;number < thirtysecondPoints; number++){
+++ for (; number < thirtysecondPoints; number++) {
++
++- // Load the 16 values
++- inputVal1 = _mm256_loadu_si256((__m256i*)inputPtr); inputPtr += 16;
++- inputVal2 = _mm256_loadu_si256((__m256i*)inputPtr); inputPtr += 16;
+++ // Load the 16 values
+++ inputVal1 = _mm256_loadu_si256((__m256i*)inputPtr);
+++ inputPtr += 16;
+++ inputVal2 = _mm256_loadu_si256((__m256i*)inputPtr);
+++ inputPtr += 16;
++
++- inputVal1 = _mm256_srai_epi16(inputVal1, 8);
++- inputVal2 = _mm256_srai_epi16(inputVal2, 8);
+++ inputVal1 = _mm256_srai_epi16(inputVal1, 8);
+++ inputVal2 = _mm256_srai_epi16(inputVal2, 8);
++
++- ret = _mm256_packs_epi16(inputVal1, inputVal2);
++- ret = _mm256_permute4x64_epi64(ret, 0b11011000);
+++ ret = _mm256_packs_epi16(inputVal1, inputVal2);
+++ ret = _mm256_permute4x64_epi64(ret, 0b11011000);
++
++- _mm256_storeu_si256((__m256i*)outputVectorPtr, ret);
+++ _mm256_storeu_si256((__m256i*)outputVectorPtr, ret);
++
++- outputVectorPtr += 32;
++- }
+++ outputVectorPtr += 32;
+++ }
++
++- number = thirtysecondPoints * 32;
++- for(; number < num_points; number++){
++- outputVector[number] =(int8_t)(inputVector[number] >> 8);
++- }
+++ number = thirtysecondPoints * 32;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (int8_t)(inputVector[number] >> 8);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -99,60 +102,62 @@ volk_16i_convert_8i_u_avx2(int8_t* outputVector, const int16_t* inputVector, uns
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_16i_convert_8i_u_sse2(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points)
+++static inline void volk_16i_convert_8i_u_sse2(int8_t* outputVector,
+++ const int16_t* inputVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- int8_t* outputVectorPtr = outputVector;
++- int16_t* inputPtr = (int16_t*)inputVector;
++- __m128i inputVal1;
++- __m128i inputVal2;
++- __m128i ret;
+++ int8_t* outputVectorPtr = outputVector;
+++ int16_t* inputPtr = (int16_t*)inputVector;
+++ __m128i inputVal1;
+++ __m128i inputVal2;
+++ __m128i ret;
++
++- for(;number < sixteenthPoints; number++){
+++ for (; number < sixteenthPoints; number++) {
++
++- // Load the 16 values
++- inputVal1 = _mm_loadu_si128((__m128i*)inputPtr); inputPtr += 8;
++- inputVal2 = _mm_loadu_si128((__m128i*)inputPtr); inputPtr += 8;
+++ // Load the 16 values
+++ inputVal1 = _mm_loadu_si128((__m128i*)inputPtr);
+++ inputPtr += 8;
+++ inputVal2 = _mm_loadu_si128((__m128i*)inputPtr);
+++ inputPtr += 8;
++
++- inputVal1 = _mm_srai_epi16(inputVal1, 8);
++- inputVal2 = _mm_srai_epi16(inputVal2, 8);
+++ inputVal1 = _mm_srai_epi16(inputVal1, 8);
+++ inputVal2 = _mm_srai_epi16(inputVal2, 8);
++
++- ret = _mm_packs_epi16(inputVal1, inputVal2);
+++ ret = _mm_packs_epi16(inputVal1, inputVal2);
++
++- _mm_storeu_si128((__m128i*)outputVectorPtr, ret);
+++ _mm_storeu_si128((__m128i*)outputVectorPtr, ret);
++
++- outputVectorPtr += 16;
++- }
+++ outputVectorPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] =(int8_t)(inputVector[number] >> 8);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (int8_t)(inputVector[number] >> 8);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_16i_convert_8i_generic(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points)
+++static inline void volk_16i_convert_8i_generic(int8_t* outputVector,
+++ const int16_t* inputVector,
+++ unsigned int num_points)
++ {
++- int8_t* outputVectorPtr = outputVector;
++- const int16_t* inputVectorPtr = inputVector;
++- unsigned int number = 0;
+++ int8_t* outputVectorPtr = outputVector;
+++ const int16_t* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((int8_t)(*inputVectorPtr++ >> 8));
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((int8_t)(*inputVectorPtr++ >> 8));
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++-
++ #endif /* INCLUDED_volk_16i_convert_8i_u_H */
++ #ifndef INCLUDED_volk_16i_convert_8i_a_H
++ #define INCLUDED_volk_16i_convert_8i_a_H
++@@ -163,39 +168,42 @@ volk_16i_convert_8i_generic(int8_t* outputVector, const int16_t* inputVector, un
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16i_convert_8i_a_avx2(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points)
+++static inline void volk_16i_convert_8i_a_avx2(int8_t* outputVector,
+++ const int16_t* inputVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int thirtysecondPoints = num_points / 32;
+++ unsigned int number = 0;
+++ const unsigned int thirtysecondPoints = num_points / 32;
++
++- int8_t* outputVectorPtr = outputVector;
++- int16_t* inputPtr = (int16_t*)inputVector;
++- __m256i inputVal1;
++- __m256i inputVal2;
++- __m256i ret;
+++ int8_t* outputVectorPtr = outputVector;
+++ int16_t* inputPtr = (int16_t*)inputVector;
+++ __m256i inputVal1;
+++ __m256i inputVal2;
+++ __m256i ret;
++
++- for(;number < thirtysecondPoints; number++){
+++ for (; number < thirtysecondPoints; number++) {
++
++- // Load the 16 values
++- inputVal1 = _mm256_load_si256((__m256i*)inputPtr); inputPtr += 16;
++- inputVal2 = _mm256_load_si256((__m256i*)inputPtr); inputPtr += 16;
+++ // Load the 16 values
+++ inputVal1 = _mm256_load_si256((__m256i*)inputPtr);
+++ inputPtr += 16;
+++ inputVal2 = _mm256_load_si256((__m256i*)inputPtr);
+++ inputPtr += 16;
++
++- inputVal1 = _mm256_srai_epi16(inputVal1, 8);
++- inputVal2 = _mm256_srai_epi16(inputVal2, 8);
+++ inputVal1 = _mm256_srai_epi16(inputVal1, 8);
+++ inputVal2 = _mm256_srai_epi16(inputVal2, 8);
++
++- ret = _mm256_packs_epi16(inputVal1, inputVal2);
++- ret = _mm256_permute4x64_epi64(ret, 0b11011000);
+++ ret = _mm256_packs_epi16(inputVal1, inputVal2);
+++ ret = _mm256_permute4x64_epi64(ret, 0b11011000);
++
++- _mm256_store_si256((__m256i*)outputVectorPtr, ret);
+++ _mm256_store_si256((__m256i*)outputVectorPtr, ret);
++
++- outputVectorPtr += 32;
++- }
+++ outputVectorPtr += 32;
+++ }
++
++- number = thirtysecondPoints * 32;
++- for(; number < num_points; number++){
++- outputVector[number] =(int8_t)(inputVector[number] >> 8);
++- }
+++ number = thirtysecondPoints * 32;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (int8_t)(inputVector[number] >> 8);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -203,38 +211,41 @@ volk_16i_convert_8i_a_avx2(int8_t* outputVector, const int16_t* inputVector, uns
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_16i_convert_8i_a_sse2(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points)
+++static inline void volk_16i_convert_8i_a_sse2(int8_t* outputVector,
+++ const int16_t* inputVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- int8_t* outputVectorPtr = outputVector;
++- int16_t* inputPtr = (int16_t*)inputVector;
++- __m128i inputVal1;
++- __m128i inputVal2;
++- __m128i ret;
+++ int8_t* outputVectorPtr = outputVector;
+++ int16_t* inputPtr = (int16_t*)inputVector;
+++ __m128i inputVal1;
+++ __m128i inputVal2;
+++ __m128i ret;
++
++- for(;number < sixteenthPoints; number++){
+++ for (; number < sixteenthPoints; number++) {
++
++- // Load the 16 values
++- inputVal1 = _mm_load_si128((__m128i*)inputPtr); inputPtr += 8;
++- inputVal2 = _mm_load_si128((__m128i*)inputPtr); inputPtr += 8;
+++ // Load the 16 values
+++ inputVal1 = _mm_load_si128((__m128i*)inputPtr);
+++ inputPtr += 8;
+++ inputVal2 = _mm_load_si128((__m128i*)inputPtr);
+++ inputPtr += 8;
++
++- inputVal1 = _mm_srai_epi16(inputVal1, 8);
++- inputVal2 = _mm_srai_epi16(inputVal2, 8);
+++ inputVal1 = _mm_srai_epi16(inputVal1, 8);
+++ inputVal2 = _mm_srai_epi16(inputVal2, 8);
++
++- ret = _mm_packs_epi16(inputVal1, inputVal2);
+++ ret = _mm_packs_epi16(inputVal1, inputVal2);
++
++- _mm_store_si128((__m128i*)outputVectorPtr, ret);
+++ _mm_store_si128((__m128i*)outputVectorPtr, ret);
++
++- outputVectorPtr += 16;
++- }
+++ outputVectorPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] =(int8_t)(inputVector[number] >> 8);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (int8_t)(inputVector[number] >> 8);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++@@ -242,53 +253,55 @@ volk_16i_convert_8i_a_sse2(int8_t* outputVector, const int16_t* inputVector, uns
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_16i_convert_8i_neon(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points)
+++static inline void volk_16i_convert_8i_neon(int8_t* outputVector,
+++ const int16_t* inputVector,
+++ unsigned int num_points)
++ {
++- int8_t* outputVectorPtr = outputVector;
++- const int16_t* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++- unsigned int sixteenth_points = num_points / 16;
++-
++- int16x8_t inputVal0;
++- int16x8_t inputVal1;
++- int8x8_t outputVal0;
++- int8x8_t outputVal1;
++- int8x16_t outputVal;
++-
++- for(number = 0; number < sixteenth_points; number++){
++- // load two input vectors
++- inputVal0 = vld1q_s16(inputVectorPtr);
++- inputVal1 = vld1q_s16(inputVectorPtr+8);
++- // shift right
++- outputVal0 = vshrn_n_s16(inputVal0, 8);
++- outputVal1 = vshrn_n_s16(inputVal1, 8);
++- // squash two vectors and write output
++- outputVal = vcombine_s8(outputVal0, outputVal1);
++- vst1q_s8(outputVectorPtr, outputVal);
++- inputVectorPtr += 16;
++- outputVectorPtr += 16;
++- }
++-
++- for(number = sixteenth_points * 16; number < num_points; number++){
++- *outputVectorPtr++ = ((int8_t)(*inputVectorPtr++ >> 8));
++- }
+++ int8_t* outputVectorPtr = outputVector;
+++ const int16_t* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++ unsigned int sixteenth_points = num_points / 16;
+++
+++ int16x8_t inputVal0;
+++ int16x8_t inputVal1;
+++ int8x8_t outputVal0;
+++ int8x8_t outputVal1;
+++ int8x16_t outputVal;
+++
+++ for (number = 0; number < sixteenth_points; number++) {
+++ // load two input vectors
+++ inputVal0 = vld1q_s16(inputVectorPtr);
+++ inputVal1 = vld1q_s16(inputVectorPtr + 8);
+++ // shift right
+++ outputVal0 = vshrn_n_s16(inputVal0, 8);
+++ outputVal1 = vshrn_n_s16(inputVal1, 8);
+++ // squash two vectors and write output
+++ outputVal = vcombine_s8(outputVal0, outputVal1);
+++ vst1q_s8(outputVectorPtr, outputVal);
+++ inputVectorPtr += 16;
+++ outputVectorPtr += 16;
+++ }
+++
+++ for (number = sixteenth_points * 16; number < num_points; number++) {
+++ *outputVectorPtr++ = ((int8_t)(*inputVectorPtr++ >> 8));
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_16i_convert_8i_a_generic(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points)
+++static inline void volk_16i_convert_8i_a_generic(int8_t* outputVector,
+++ const int16_t* inputVector,
+++ unsigned int num_points)
++ {
++- int8_t* outputVectorPtr = outputVector;
++- const int16_t* inputVectorPtr = inputVector;
++- unsigned int number = 0;
+++ int8_t* outputVectorPtr = outputVector;
+++ const int16_t* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((int8_t)(*inputVectorPtr++ >> 8));
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((int8_t)(*inputVectorPtr++ >> 8));
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_16i_max_star_16i.h b/kernels/volk/volk_16i_max_star_16i.h
++index 78fd911..d5dad18 100644
++--- a/kernels/volk/volk_16i_max_star_16i.h
+++++ b/kernels/volk/volk_16i_max_star_16i.h
++@@ -53,67 +53,69 @@
++ #ifndef INCLUDED_volk_16i_max_star_16i_a_H
++ #define INCLUDED_volk_16i_max_star_16i_a_H
++
++-#include<inttypes.h>
++-#include<stdio.h>
+++#include <inttypes.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_SSSE3
++
++-#include<xmmintrin.h>
++-#include<emmintrin.h>
++-#include<tmmintrin.h>
+++#include <emmintrin.h>
+++#include <tmmintrin.h>
+++#include <xmmintrin.h>
++
++ static inline void
++ volk_16i_max_star_16i_a_ssse3(short* target, short* src0, unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*2;
+++ const unsigned int num_bytes = num_points * 2;
++
++- short candidate = src0[0];
++- short cands[8];
++- __m128i xmm0, xmm1, xmm3, xmm4, xmm5, xmm6;
+++ short candidate = src0[0];
+++ short cands[8];
+++ __m128i xmm0, xmm1, xmm3, xmm4, xmm5, xmm6;
++
++- __m128i *p_src0;
+++ __m128i* p_src0;
++
++- p_src0 = (__m128i*)src0;
+++ p_src0 = (__m128i*)src0;
++
++- int bound = num_bytes >> 4;
++- int leftovers = (num_bytes >> 1) & 7;
+++ int bound = num_bytes >> 4;
+++ int leftovers = (num_bytes >> 1) & 7;
++
++- int i = 0;
+++ int i = 0;
++
++- xmm1 = _mm_setzero_si128();
++- xmm0 = _mm_setzero_si128();
++- //_mm_insert_epi16(xmm0, candidate, 0);
+++ xmm1 = _mm_setzero_si128();
+++ xmm0 = _mm_setzero_si128();
+++ //_mm_insert_epi16(xmm0, candidate, 0);
++
++- xmm0 = _mm_shuffle_epi8(xmm0, xmm1);
+++ xmm0 = _mm_shuffle_epi8(xmm0, xmm1);
++
++- for(i = 0; i < bound; ++i) {
++- xmm1 = _mm_load_si128(p_src0);
++- p_src0 += 1;
++- //xmm2 = _mm_sub_epi16(xmm1, xmm0);
+++ for (i = 0; i < bound; ++i) {
+++ xmm1 = _mm_load_si128(p_src0);
+++ p_src0 += 1;
+++ // xmm2 = _mm_sub_epi16(xmm1, xmm0);
++
++- xmm3 = _mm_cmpgt_epi16(xmm0, xmm1);
++- xmm4 = _mm_cmpeq_epi16(xmm0, xmm1);
++- xmm5 = _mm_cmpgt_epi16(xmm1, xmm0);
+++ xmm3 = _mm_cmpgt_epi16(xmm0, xmm1);
+++ xmm4 = _mm_cmpeq_epi16(xmm0, xmm1);
+++ xmm5 = _mm_cmpgt_epi16(xmm1, xmm0);
++
++- xmm6 = _mm_xor_si128(xmm4, xmm5);
+++ xmm6 = _mm_xor_si128(xmm4, xmm5);
++
++- xmm3 = _mm_and_si128(xmm3, xmm0);
++- xmm4 = _mm_and_si128(xmm6, xmm1);
+++ xmm3 = _mm_and_si128(xmm3, xmm0);
+++ xmm4 = _mm_and_si128(xmm6, xmm1);
++
++- xmm0 = _mm_add_epi16(xmm3, xmm4);
++- }
+++ xmm0 = _mm_add_epi16(xmm3, xmm4);
+++ }
++
++- _mm_store_si128((__m128i*)cands, xmm0);
+++ _mm_store_si128((__m128i*)cands, xmm0);
++
++- for(i = 0; i < 8; ++i) {
++- candidate = ((short)(candidate - cands[i]) > 0) ? candidate : cands[i];
++- }
+++ for (i = 0; i < 8; ++i) {
+++ candidate = ((short)(candidate - cands[i]) > 0) ? candidate : cands[i];
+++ }
++
++- for(i = 0; i < leftovers; ++i) {
++- candidate = ((short)(candidate - src0[(bound << 3) + i]) > 0) ? candidate : src0[(bound << 3) + i];
++- }
+++ for (i = 0; i < leftovers; ++i) {
+++ candidate = ((short)(candidate - src0[(bound << 3) + i]) > 0)
+++ ? candidate
+++ : src0[(bound << 3) + i];
+++ }
++
++- target[0] = candidate;
+++ target[0] = candidate;
++ }
++
++ #endif /*LV_HAVE_SSSE3*/
++@@ -124,38 +126,38 @@ volk_16i_max_star_16i_a_ssse3(short* target, short* src0, unsigned int num_point
++ static inline void
++ volk_16i_max_star_16i_neon(short* target, short* src0, unsigned int num_points)
++ {
++- const unsigned int eighth_points = num_points / 8;
++- unsigned number;
++- int16x8_t input_vec;
++- int16x8_t diff, zeros;
++- uint16x8_t comp1, comp2;
++- zeros = vdupq_n_s16(0);
++-
++- int16x8x2_t tmpvec;
++-
++- int16x8_t candidate_vec = vld1q_dup_s16(src0 );
++- short candidate;
++- ++src0;
++-
++- for(number=0; number < eighth_points; ++number) {
++- input_vec = vld1q_s16(src0);
++- __VOLK_PREFETCH(src0+16);
++- diff = vsubq_s16(candidate_vec, input_vec);
++- comp1 = vcgeq_s16(diff, zeros);
++- comp2 = vcltq_s16(diff, zeros);
++-
++- tmpvec.val[0] = vandq_s16(candidate_vec, (int16x8_t)comp1);
++- tmpvec.val[1] = vandq_s16(input_vec, (int16x8_t)comp2);
++-
++- candidate_vec = vaddq_s16(tmpvec.val[0], tmpvec.val[1]);
++- src0 += 8;
++- }
++- vst1q_s16(&candidate, candidate_vec);
++-
++- for(number=0; number < num_points%8; number++) {
++- candidate = ((int16_t)(candidate - src0[number]) > 0) ? candidate : src0[number];
++- }
++- target[0] = candidate;
+++ const unsigned int eighth_points = num_points / 8;
+++ unsigned number;
+++ int16x8_t input_vec;
+++ int16x8_t diff, zeros;
+++ uint16x8_t comp1, comp2;
+++ zeros = vdupq_n_s16(0);
+++
+++ int16x8x2_t tmpvec;
+++
+++ int16x8_t candidate_vec = vld1q_dup_s16(src0);
+++ short candidate;
+++ ++src0;
+++
+++ for (number = 0; number < eighth_points; ++number) {
+++ input_vec = vld1q_s16(src0);
+++ __VOLK_PREFETCH(src0 + 16);
+++ diff = vsubq_s16(candidate_vec, input_vec);
+++ comp1 = vcgeq_s16(diff, zeros);
+++ comp2 = vcltq_s16(diff, zeros);
+++
+++ tmpvec.val[0] = vandq_s16(candidate_vec, (int16x8_t)comp1);
+++ tmpvec.val[1] = vandq_s16(input_vec, (int16x8_t)comp2);
+++
+++ candidate_vec = vaddq_s16(tmpvec.val[0], tmpvec.val[1]);
+++ src0 += 8;
+++ }
+++ vst1q_s16(&candidate, candidate_vec);
+++
+++ for (number = 0; number < num_points % 8; number++) {
+++ candidate = ((int16_t)(candidate - src0[number]) > 0) ? candidate : src0[number];
+++ }
+++ target[0] = candidate;
++ }
++ #endif /*LV_HAVE_NEON*/
++
++@@ -164,17 +166,17 @@ volk_16i_max_star_16i_neon(short* target, short* src0, unsigned int num_points)
++ static inline void
++ volk_16i_max_star_16i_generic(short* target, short* src0, unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*2;
+++ const unsigned int num_bytes = num_points * 2;
++
++- int i = 0;
+++ int i = 0;
++
++- int bound = num_bytes >> 1;
+++ int bound = num_bytes >> 1;
++
++- short candidate = src0[0];
++- for(i = 1; i < bound; ++i) {
++- candidate = ((short)(candidate - src0[i]) > 0) ? candidate : src0[i];
++- }
++- target[0] = candidate;
+++ short candidate = src0[0];
+++ for (i = 1; i < bound; ++i) {
+++ candidate = ((short)(candidate - src0[i]) > 0) ? candidate : src0[i];
+++ }
+++ target[0] = candidate;
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++diff --git a/kernels/volk/volk_16i_max_star_horizontal_16i.h b/kernels/volk/volk_16i_max_star_horizontal_16i.h
++index 4ffe264..2e1f52b 100644
++--- a/kernels/volk/volk_16i_max_star_horizontal_16i.h
+++++ b/kernels/volk/volk_16i_max_star_horizontal_16i.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16i_max_star_horizontal_16i(short* target, short* src0, unsigned int num_points);
++- * \endcode
+++ * void volk_16i_max_star_horizontal_16i(short* target, short* src0, unsigned int
+++ * num_points); \endcode
++ *
++ * \b Inputs
++ * \li src0: The input vector.
++@@ -55,102 +55,113 @@
++
++ #include <volk/volk_common.h>
++
++-#include<inttypes.h>
++-#include<stdio.h>
+++#include <inttypes.h>
+++#include <stdio.h>
++
++
++ #ifdef LV_HAVE_SSSE3
++
++-#include<xmmintrin.h>
++-#include<emmintrin.h>
++-#include<tmmintrin.h>
+++#include <emmintrin.h>
+++#include <tmmintrin.h>
+++#include <xmmintrin.h>
++
++-static inline void
++-volk_16i_max_star_horizontal_16i_a_ssse3(int16_t* target, int16_t* src0, unsigned int num_points)
+++static inline void volk_16i_max_star_horizontal_16i_a_ssse3(int16_t* target,
+++ int16_t* src0,
+++ unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*2;
+++ const unsigned int num_bytes = num_points * 2;
++
++- static const uint8_t shufmask0[16] = {0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0c, 0x0d, 0xff,
++- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
++- static const uint8_t shufmask1[16] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
++- 0x01, 0x04, 0x05, 0x08, 0x09, 0x0c, 0x0d};
++- static const uint8_t andmask0[16] = {0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,0x02, 0x00,
++- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
++- static const uint8_t andmask1[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
++- 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02};
+++ static const uint8_t shufmask0[16] = {
+++ 0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0c, 0x0d,
+++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+++ };
+++ static const uint8_t shufmask1[16] = {
+++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+++ 0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0c, 0x0d
+++ };
+++ static const uint8_t andmask0[16] = {
+++ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+++ };
+++ static const uint8_t andmask1[16] = {
+++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+++ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
+++ };
++
++- __m128i xmm0, xmm1, xmm2, xmm3, xmm4;
++- __m128i xmm5, xmm6, xmm7, xmm8;
+++ __m128i xmm0, xmm1, xmm2, xmm3, xmm4;
+++ __m128i xmm5, xmm6, xmm7, xmm8;
++
++- xmm4 = _mm_load_si128((__m128i*)shufmask0);
++- xmm5 = _mm_load_si128((__m128i*)shufmask1);
++- xmm6 = _mm_load_si128((__m128i*)andmask0);
++- xmm7 = _mm_load_si128((__m128i*)andmask1);
+++ xmm4 = _mm_load_si128((__m128i*)shufmask0);
+++ xmm5 = _mm_load_si128((__m128i*)shufmask1);
+++ xmm6 = _mm_load_si128((__m128i*)andmask0);
+++ xmm7 = _mm_load_si128((__m128i*)andmask1);
++
++- __m128i *p_target, *p_src0;
+++ __m128i *p_target, *p_src0;
++
++- p_target = (__m128i*)target;
++- p_src0 = (__m128i*)src0;
+++ p_target = (__m128i*)target;
+++ p_src0 = (__m128i*)src0;
++
++- int bound = num_bytes >> 5;
++- int intermediate = (num_bytes >> 4) & 1;
++- int leftovers = (num_bytes >> 1) & 7;
+++ int bound = num_bytes >> 5;
+++ int intermediate = (num_bytes >> 4) & 1;
+++ int leftovers = (num_bytes >> 1) & 7;
++
++- int i = 0;
+++ int i = 0;
++
++- for(i = 0; i < bound; ++i) {
++- xmm0 = _mm_load_si128(p_src0);
++- xmm1 = _mm_load_si128(&p_src0[1]);
+++ for (i = 0; i < bound; ++i) {
+++ xmm0 = _mm_load_si128(p_src0);
+++ xmm1 = _mm_load_si128(&p_src0[1]);
++
++- xmm2 = _mm_xor_si128(xmm2, xmm2);
++- p_src0 += 2;
+++ xmm2 = _mm_xor_si128(xmm2, xmm2);
+++ p_src0 += 2;
++
++- xmm3 = _mm_hsub_epi16(xmm0, xmm1);
+++ xmm3 = _mm_hsub_epi16(xmm0, xmm1);
++
++- xmm2 = _mm_cmpgt_epi16(xmm2, xmm3);
+++ xmm2 = _mm_cmpgt_epi16(xmm2, xmm3);
++
++- xmm8 = _mm_and_si128(xmm2, xmm6);
++- xmm3 = _mm_and_si128(xmm2, xmm7);
+++ xmm8 = _mm_and_si128(xmm2, xmm6);
+++ xmm3 = _mm_and_si128(xmm2, xmm7);
++
++
++- xmm8 = _mm_add_epi8(xmm8, xmm4);
++- xmm3 = _mm_add_epi8(xmm3, xmm5);
+++ xmm8 = _mm_add_epi8(xmm8, xmm4);
+++ xmm3 = _mm_add_epi8(xmm3, xmm5);
++
++- xmm0 = _mm_shuffle_epi8(xmm0, xmm8);
++- xmm1 = _mm_shuffle_epi8(xmm1, xmm3);
+++ xmm0 = _mm_shuffle_epi8(xmm0, xmm8);
+++ xmm1 = _mm_shuffle_epi8(xmm1, xmm3);
++
++
++- xmm3 = _mm_add_epi16(xmm0, xmm1);
+++ xmm3 = _mm_add_epi16(xmm0, xmm1);
++
++
++- _mm_store_si128(p_target, xmm3);
+++ _mm_store_si128(p_target, xmm3);
++
++- p_target += 1;
++- }
+++ p_target += 1;
+++ }
++
++- if (intermediate) {
++- xmm0 = _mm_load_si128(p_src0);
+++ if (intermediate) {
+++ xmm0 = _mm_load_si128(p_src0);
++
++- xmm2 = _mm_xor_si128(xmm2, xmm2);
++- p_src0 += 1;
+++ xmm2 = _mm_xor_si128(xmm2, xmm2);
+++ p_src0 += 1;
++
++- xmm3 = _mm_hsub_epi16(xmm0, xmm1);
++- xmm2 = _mm_cmpgt_epi16(xmm2, xmm3);
+++ xmm3 = _mm_hsub_epi16(xmm0, xmm1);
+++ xmm2 = _mm_cmpgt_epi16(xmm2, xmm3);
++
++- xmm8 = _mm_and_si128(xmm2, xmm6);
+++ xmm8 = _mm_and_si128(xmm2, xmm6);
++
++- xmm3 = _mm_add_epi8(xmm8, xmm4);
+++ xmm3 = _mm_add_epi8(xmm8, xmm4);
++
++- xmm0 = _mm_shuffle_epi8(xmm0, xmm3);
+++ xmm0 = _mm_shuffle_epi8(xmm0, xmm3);
++
++- _mm_storel_pd((double*)p_target, bit128_p(&xmm0)->double_vec);
+++ _mm_storel_pd((double*)p_target, bit128_p(&xmm0)->double_vec);
++
++- p_target = (__m128i*)((int8_t*)p_target + 8);
++- }
+++ p_target = (__m128i*)((int8_t*)p_target + 8);
+++ }
++
++- for(i = (bound << 4) + (intermediate << 3); i < (bound << 4) + (intermediate << 3) + leftovers ; i += 2) {
++- target[i>>1] = ((int16_t)(src0[i] - src0[i + 1]) > 0) ? src0[i] : src0[i + 1];
++- }
+++ for (i = (bound << 4) + (intermediate << 3);
+++ i < (bound << 4) + (intermediate << 3) + leftovers;
+++ i += 2) {
+++ target[i >> 1] = ((int16_t)(src0[i] - src0[i + 1]) > 0) ? src0[i] : src0[i + 1];
+++ }
++ }
++
++ #endif /*LV_HAVE_SSSE3*/
++@@ -158,54 +169,59 @@ volk_16i_max_star_horizontal_16i_a_ssse3(int16_t* target, int16_t* src0, unsigne
++ #ifdef LV_HAVE_NEON
++
++ #include <arm_neon.h>
++-static inline void
++-volk_16i_max_star_horizontal_16i_neon(int16_t* target, int16_t* src0, unsigned int num_points)
+++static inline void volk_16i_max_star_horizontal_16i_neon(int16_t* target,
+++ int16_t* src0,
+++ unsigned int num_points)
++ {
++- const unsigned int eighth_points = num_points / 16;
++- unsigned number;
++- int16x8x2_t input_vec;
++- int16x8_t diff, max_vec, zeros;
++- uint16x8_t comp1, comp2;
++- zeros = vdupq_n_s16(0);
++- for(number=0; number < eighth_points; ++number) {
++- input_vec = vld2q_s16(src0);
++- //__VOLK_PREFETCH(src0+16);
++- diff = vsubq_s16(input_vec.val[0], input_vec.val[1]);
++- comp1 = vcgeq_s16(diff, zeros);
++- comp2 = vcltq_s16(diff, zeros);
++-
++- input_vec.val[0] = vandq_s16(input_vec.val[0], (int16x8_t)comp1);
++- input_vec.val[1] = vandq_s16(input_vec.val[1], (int16x8_t)comp2);
++-
++- max_vec = vaddq_s16(input_vec.val[0], input_vec.val[1]);
++- vst1q_s16(target, max_vec);
++- src0 += 16;
++- target += 8;
++- }
++- for(number=0; number < num_points%16; number+=2) {
++- target[number >> 1] = ((int16_t)(src0[number] - src0[number + 1]) > 0) ? src0[number] : src0[number+1];
++- }
++-
+++ const unsigned int eighth_points = num_points / 16;
+++ unsigned number;
+++ int16x8x2_t input_vec;
+++ int16x8_t diff, max_vec, zeros;
+++ uint16x8_t comp1, comp2;
+++ zeros = vdupq_n_s16(0);
+++ for (number = 0; number < eighth_points; ++number) {
+++ input_vec = vld2q_s16(src0);
+++ //__VOLK_PREFETCH(src0+16);
+++ diff = vsubq_s16(input_vec.val[0], input_vec.val[1]);
+++ comp1 = vcgeq_s16(diff, zeros);
+++ comp2 = vcltq_s16(diff, zeros);
+++
+++ input_vec.val[0] = vandq_s16(input_vec.val[0], (int16x8_t)comp1);
+++ input_vec.val[1] = vandq_s16(input_vec.val[1], (int16x8_t)comp2);
+++
+++ max_vec = vaddq_s16(input_vec.val[0], input_vec.val[1]);
+++ vst1q_s16(target, max_vec);
+++ src0 += 16;
+++ target += 8;
+++ }
+++ for (number = 0; number < num_points % 16; number += 2) {
+++ target[number >> 1] = ((int16_t)(src0[number] - src0[number + 1]) > 0)
+++ ? src0[number]
+++ : src0[number + 1];
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++ #ifdef LV_HAVE_NEONV7
++-extern void volk_16i_max_star_horizontal_16i_a_neonasm(int16_t* target, int16_t* src0, unsigned int num_points);
+++extern void volk_16i_max_star_horizontal_16i_a_neonasm(int16_t* target,
+++ int16_t* src0,
+++ unsigned int num_points);
++ #endif /* LV_HAVE_NEONV7 */
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void
++-volk_16i_max_star_horizontal_16i_generic(int16_t* target, int16_t* src0, unsigned int num_points)
+++static inline void volk_16i_max_star_horizontal_16i_generic(int16_t* target,
+++ int16_t* src0,
+++ unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*2;
+++ const unsigned int num_bytes = num_points * 2;
++
++- int i = 0;
+++ int i = 0;
++
++- int bound = num_bytes >> 1;
+++ int bound = num_bytes >> 1;
++
++- for(i = 0; i < bound; i += 2) {
++- target[i >> 1] = ((int16_t) (src0[i] - src0[i + 1]) > 0) ? src0[i] : src0[i+1];
++- }
+++ for (i = 0; i < bound; i += 2) {
+++ target[i >> 1] = ((int16_t)(src0[i] - src0[i + 1]) > 0) ? src0[i] : src0[i + 1];
+++ }
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++diff --git a/kernels/volk/volk_16i_permute_and_scalar_add.h b/kernels/volk/volk_16i_permute_and_scalar_add.h
++index 7fcdad3..0563f07 100644
++--- a/kernels/volk/volk_16i_permute_and_scalar_add.h
+++++ b/kernels/volk/volk_16i_permute_and_scalar_add.h
++@@ -29,8 +29,9 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16i_permute_and_scalar_add(short* target, short* src0, short* permute_indexes, short* cntl0, short* cntl1, short* cntl2, short* cntl3, short* scalars, unsigned int num_points)
++- * \endcode
+++ * void volk_16i_permute_and_scalar_add(short* target, short* src0, short*
+++ * permute_indexes, short* cntl0, short* cntl1, short* cntl2, short* cntl3, short*
+++ * scalars, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li src0: The input vector.
++@@ -58,137 +59,143 @@
++ #ifndef INCLUDED_volk_16i_permute_and_scalar_add_a_H
++ #define INCLUDED_volk_16i_permute_and_scalar_add_a_H
++
++-#include<inttypes.h>
++-#include<stdio.h>
+++#include <inttypes.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_SSE2
++
++-#include<xmmintrin.h>
++-#include<emmintrin.h>
++-
++-static inline void
++-volk_16i_permute_and_scalar_add_a_sse2(short* target, short* src0, short* permute_indexes,
++- short* cntl0, short* cntl1, short* cntl2, short* cntl3,
++- short* scalars, unsigned int num_points)
+++#include <emmintrin.h>
+++#include <xmmintrin.h>
+++
+++static inline void volk_16i_permute_and_scalar_add_a_sse2(short* target,
+++ short* src0,
+++ short* permute_indexes,
+++ short* cntl0,
+++ short* cntl1,
+++ short* cntl2,
+++ short* cntl3,
+++ short* scalars,
+++ unsigned int num_points)
++ {
++
++- const unsigned int num_bytes = num_points*2;
+++ const unsigned int num_bytes = num_points * 2;
++
++- __m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
+++ __m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
++
++- __m128i *p_target, *p_cntl0, *p_cntl1, *p_cntl2, *p_cntl3, *p_scalars;
+++ __m128i *p_target, *p_cntl0, *p_cntl1, *p_cntl2, *p_cntl3, *p_scalars;
++
++- short* p_permute_indexes = permute_indexes;
+++ short* p_permute_indexes = permute_indexes;
++
++- p_target = (__m128i*)target;
++- p_cntl0 = (__m128i*)cntl0;
++- p_cntl1 = (__m128i*)cntl1;
++- p_cntl2 = (__m128i*)cntl2;
++- p_cntl3 = (__m128i*)cntl3;
++- p_scalars = (__m128i*)scalars;
+++ p_target = (__m128i*)target;
+++ p_cntl0 = (__m128i*)cntl0;
+++ p_cntl1 = (__m128i*)cntl1;
+++ p_cntl2 = (__m128i*)cntl2;
+++ p_cntl3 = (__m128i*)cntl3;
+++ p_scalars = (__m128i*)scalars;
++
++- int i = 0;
+++ int i = 0;
++
++- int bound = (num_bytes >> 4);
++- int leftovers = (num_bytes >> 1) & 7;
+++ int bound = (num_bytes >> 4);
+++ int leftovers = (num_bytes >> 1) & 7;
++
++- xmm0 = _mm_load_si128(p_scalars);
+++ xmm0 = _mm_load_si128(p_scalars);
++
++- xmm1 = _mm_shufflelo_epi16(xmm0, 0);
++- xmm2 = _mm_shufflelo_epi16(xmm0, 0x55);
++- xmm3 = _mm_shufflelo_epi16(xmm0, 0xaa);
++- xmm4 = _mm_shufflelo_epi16(xmm0, 0xff);
+++ xmm1 = _mm_shufflelo_epi16(xmm0, 0);
+++ xmm2 = _mm_shufflelo_epi16(xmm0, 0x55);
+++ xmm3 = _mm_shufflelo_epi16(xmm0, 0xaa);
+++ xmm4 = _mm_shufflelo_epi16(xmm0, 0xff);
++
++- xmm1 = _mm_shuffle_epi32(xmm1, 0x00);
++- xmm2 = _mm_shuffle_epi32(xmm2, 0x00);
++- xmm3 = _mm_shuffle_epi32(xmm3, 0x00);
++- xmm4 = _mm_shuffle_epi32(xmm4, 0x00);
+++ xmm1 = _mm_shuffle_epi32(xmm1, 0x00);
+++ xmm2 = _mm_shuffle_epi32(xmm2, 0x00);
+++ xmm3 = _mm_shuffle_epi32(xmm3, 0x00);
+++ xmm4 = _mm_shuffle_epi32(xmm4, 0x00);
++
++
++- for(; i < bound; ++i) {
++- xmm0 = _mm_setzero_si128();
++- xmm5 = _mm_setzero_si128();
++- xmm6 = _mm_setzero_si128();
++- xmm7 = _mm_setzero_si128();
+++ for (; i < bound; ++i) {
+++ xmm0 = _mm_setzero_si128();
+++ xmm5 = _mm_setzero_si128();
+++ xmm6 = _mm_setzero_si128();
+++ xmm7 = _mm_setzero_si128();
++
++- xmm0 = _mm_insert_epi16(xmm0, src0[p_permute_indexes[0]], 0);
++- xmm5 = _mm_insert_epi16(xmm5, src0[p_permute_indexes[1]], 1);
++- xmm6 = _mm_insert_epi16(xmm6, src0[p_permute_indexes[2]], 2);
++- xmm7 = _mm_insert_epi16(xmm7, src0[p_permute_indexes[3]], 3);
++- xmm0 = _mm_insert_epi16(xmm0, src0[p_permute_indexes[4]], 4);
++- xmm5 = _mm_insert_epi16(xmm5, src0[p_permute_indexes[5]], 5);
++- xmm6 = _mm_insert_epi16(xmm6, src0[p_permute_indexes[6]], 6);
++- xmm7 = _mm_insert_epi16(xmm7, src0[p_permute_indexes[7]], 7);
+++ xmm0 = _mm_insert_epi16(xmm0, src0[p_permute_indexes[0]], 0);
+++ xmm5 = _mm_insert_epi16(xmm5, src0[p_permute_indexes[1]], 1);
+++ xmm6 = _mm_insert_epi16(xmm6, src0[p_permute_indexes[2]], 2);
+++ xmm7 = _mm_insert_epi16(xmm7, src0[p_permute_indexes[3]], 3);
+++ xmm0 = _mm_insert_epi16(xmm0, src0[p_permute_indexes[4]], 4);
+++ xmm5 = _mm_insert_epi16(xmm5, src0[p_permute_indexes[5]], 5);
+++ xmm6 = _mm_insert_epi16(xmm6, src0[p_permute_indexes[6]], 6);
+++ xmm7 = _mm_insert_epi16(xmm7, src0[p_permute_indexes[7]], 7);
++
++- xmm0 = _mm_add_epi16(xmm0, xmm5);
++- xmm6 = _mm_add_epi16(xmm6, xmm7);
+++ xmm0 = _mm_add_epi16(xmm0, xmm5);
+++ xmm6 = _mm_add_epi16(xmm6, xmm7);
++
++- p_permute_indexes += 8;
+++ p_permute_indexes += 8;
++
++- xmm0 = _mm_add_epi16(xmm0, xmm6);
+++ xmm0 = _mm_add_epi16(xmm0, xmm6);
++
++- xmm5 = _mm_load_si128(p_cntl0);
++- xmm6 = _mm_load_si128(p_cntl1);
++- xmm7 = _mm_load_si128(p_cntl2);
+++ xmm5 = _mm_load_si128(p_cntl0);
+++ xmm6 = _mm_load_si128(p_cntl1);
+++ xmm7 = _mm_load_si128(p_cntl2);
++
++- xmm5 = _mm_and_si128(xmm5, xmm1);
++- xmm6 = _mm_and_si128(xmm6, xmm2);
++- xmm7 = _mm_and_si128(xmm7, xmm3);
+++ xmm5 = _mm_and_si128(xmm5, xmm1);
+++ xmm6 = _mm_and_si128(xmm6, xmm2);
+++ xmm7 = _mm_and_si128(xmm7, xmm3);
++
++- xmm0 = _mm_add_epi16(xmm0, xmm5);
+++ xmm0 = _mm_add_epi16(xmm0, xmm5);
++
++- xmm5 = _mm_load_si128(p_cntl3);
+++ xmm5 = _mm_load_si128(p_cntl3);
++
++- xmm6 = _mm_add_epi16(xmm6, xmm7);
+++ xmm6 = _mm_add_epi16(xmm6, xmm7);
++
++- p_cntl0 += 1;
+++ p_cntl0 += 1;
++
++- xmm5 = _mm_and_si128(xmm5, xmm4);
+++ xmm5 = _mm_and_si128(xmm5, xmm4);
++
++- xmm0 = _mm_add_epi16(xmm0, xmm6);
+++ xmm0 = _mm_add_epi16(xmm0, xmm6);
++
++- p_cntl1 += 1;
++- p_cntl2 += 1;
+++ p_cntl1 += 1;
+++ p_cntl2 += 1;
++
++- xmm0 = _mm_add_epi16(xmm0, xmm5);
+++ xmm0 = _mm_add_epi16(xmm0, xmm5);
++
++- p_cntl3 += 1;
+++ p_cntl3 += 1;
++
++- _mm_store_si128(p_target, xmm0);
+++ _mm_store_si128(p_target, xmm0);
++
++- p_target += 1;
++- }
+++ p_target += 1;
+++ }
++
++- for(i = bound * 8; i < (bound * 8) + leftovers; ++i) {
++- target[i] = src0[permute_indexes[i]]
++- + (cntl0[i] & scalars[0])
++- + (cntl1[i] & scalars[1])
++- + (cntl2[i] & scalars[2])
++- + (cntl3[i] & scalars[3]);
++- }
+++ for (i = bound * 8; i < (bound * 8) + leftovers; ++i) {
+++ target[i] = src0[permute_indexes[i]] + (cntl0[i] & scalars[0]) +
+++ (cntl1[i] & scalars[1]) + (cntl2[i] & scalars[2]) +
+++ (cntl3[i] & scalars[3]);
+++ }
++ }
++ #endif /*LV_HAVE_SSE*/
++
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void
++-volk_16i_permute_and_scalar_add_generic(short* target, short* src0, short* permute_indexes,
++- short* cntl0, short* cntl1, short* cntl2, short* cntl3,
++- short* scalars, unsigned int num_points)
+++static inline void volk_16i_permute_and_scalar_add_generic(short* target,
+++ short* src0,
+++ short* permute_indexes,
+++ short* cntl0,
+++ short* cntl1,
+++ short* cntl2,
+++ short* cntl3,
+++ short* scalars,
+++ unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*2;
+++ const unsigned int num_bytes = num_points * 2;
++
++- int i = 0;
+++ int i = 0;
++
++- int bound = num_bytes >> 1;
+++ int bound = num_bytes >> 1;
++
++- for(i = 0; i < bound; ++i) {
++- target[i] = src0[permute_indexes[i]]
++- + (cntl0[i] & scalars[0])
++- + (cntl1[i] & scalars[1])
++- + (cntl2[i] & scalars[2])
++- + (cntl3[i] & scalars[3]);
++- }
+++ for (i = 0; i < bound; ++i) {
+++ target[i] = src0[permute_indexes[i]] + (cntl0[i] & scalars[0]) +
+++ (cntl1[i] & scalars[1]) + (cntl2[i] & scalars[2]) +
+++ (cntl3[i] & scalars[3]);
+++ }
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++diff --git a/kernels/volk/volk_16i_s32f_convert_32f.h b/kernels/volk/volk_16i_s32f_convert_32f.h
++index 38ea6f5..3fd3a77 100644
++--- a/kernels/volk/volk_16i_s32f_convert_32f.h
+++++ b/kernels/volk/volk_16i_s32f_convert_32f.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16i_s32f_convert_32f(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points);
++- * \endcode
+++ * void volk_16i_s32f_convert_32f(float* outputVector, const int16_t* inputVector, const
+++ * float scalar, unsigned int num_points); \endcode
++ *
++ * \b Inputs
++ * \li inputVector: The input vector of 16-bit shorts.
++@@ -60,238 +60,247 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16i_s32f_convert_32f_u_avx2(float* outputVector, const int16_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16i_s32f_convert_32f_u_avx2(float* outputVector,
+++ const int16_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* outputVectorPtr = outputVector;
++- __m256 invScalar = _mm256_set1_ps(1.0/scalar);
++- int16_t* inputPtr = (int16_t*)inputVector;
++- __m128i inputVal;
++- __m256i inputVal2;
++- __m256 ret;
+++ float* outputVectorPtr = outputVector;
+++ __m256 invScalar = _mm256_set1_ps(1.0 / scalar);
+++ int16_t* inputPtr = (int16_t*)inputVector;
+++ __m128i inputVal;
+++ __m256i inputVal2;
+++ __m256 ret;
++
++- for(;number < eighthPoints; number++){
+++ for (; number < eighthPoints; number++) {
++
++- // Load the 8 values
++- inputVal = _mm_loadu_si128((__m128i*)inputPtr);
+++ // Load the 8 values
+++ inputVal = _mm_loadu_si128((__m128i*)inputPtr);
++
++- // Convert
++- inputVal2 = _mm256_cvtepi16_epi32(inputVal);
+++ // Convert
+++ inputVal2 = _mm256_cvtepi16_epi32(inputVal);
++
++- ret = _mm256_cvtepi32_ps(inputVal2);
++- ret = _mm256_mul_ps(ret, invScalar);
+++ ret = _mm256_cvtepi32_ps(inputVal2);
+++ ret = _mm256_mul_ps(ret, invScalar);
++
++- _mm256_storeu_ps(outputVectorPtr, ret);
+++ _mm256_storeu_ps(outputVectorPtr, ret);
++
++- outputVectorPtr += 8;
+++ outputVectorPtr += 8;
++
++- inputPtr += 8;
++- }
+++ inputPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- outputVector[number] =((float)(inputVector[number])) / scalar;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = ((float)(inputVector[number])) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_16i_s32f_convert_32f_u_avx(float* outputVector, const int16_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16i_s32f_convert_32f_u_avx(float* outputVector,
+++ const int16_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* outputVectorPtr = outputVector;
++- __m128 invScalar = _mm_set_ps1(1.0/scalar);
++- int16_t* inputPtr = (int16_t*)inputVector;
++- __m128i inputVal, inputVal2;
++- __m128 ret;
++- __m256 output;
++- __m256 dummy = _mm256_setzero_ps();
+++ float* outputVectorPtr = outputVector;
+++ __m128 invScalar = _mm_set_ps1(1.0 / scalar);
+++ int16_t* inputPtr = (int16_t*)inputVector;
+++ __m128i inputVal, inputVal2;
+++ __m128 ret;
+++ __m256 output;
+++ __m256 dummy = _mm256_setzero_ps();
++
++- for(;number < eighthPoints; number++){
+++ for (; number < eighthPoints; number++) {
++
++- // Load the 8 values
++- //inputVal = _mm_loadu_si128((__m128i*)inputPtr);
++- inputVal = _mm_loadu_si128((__m128i*)inputPtr);
+++ // Load the 8 values
+++ // inputVal = _mm_loadu_si128((__m128i*)inputPtr);
+++ inputVal = _mm_loadu_si128((__m128i*)inputPtr);
++
++- // Shift the input data to the right by 64 bits ( 8 bytes )
++- inputVal2 = _mm_srli_si128(inputVal, 8);
+++ // Shift the input data to the right by 64 bits ( 8 bytes )
+++ inputVal2 = _mm_srli_si128(inputVal, 8);
++
++- // Convert the lower 4 values into 32 bit words
++- inputVal = _mm_cvtepi16_epi32(inputVal);
++- inputVal2 = _mm_cvtepi16_epi32(inputVal2);
+++ // Convert the lower 4 values into 32 bit words
+++ inputVal = _mm_cvtepi16_epi32(inputVal);
+++ inputVal2 = _mm_cvtepi16_epi32(inputVal2);
++
++- ret = _mm_cvtepi32_ps(inputVal);
++- ret = _mm_mul_ps(ret, invScalar);
++- output = _mm256_insertf128_ps(dummy, ret, 0);
+++ ret = _mm_cvtepi32_ps(inputVal);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ output = _mm256_insertf128_ps(dummy, ret, 0);
++
++- ret = _mm_cvtepi32_ps(inputVal2);
++- ret = _mm_mul_ps(ret, invScalar);
++- output = _mm256_insertf128_ps(output, ret, 1);
+++ ret = _mm_cvtepi32_ps(inputVal2);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ output = _mm256_insertf128_ps(output, ret, 1);
++
++- _mm256_storeu_ps(outputVectorPtr, output);
+++ _mm256_storeu_ps(outputVectorPtr, output);
++
++- outputVectorPtr += 8;
+++ outputVectorPtr += 8;
++
++- inputPtr += 8;
++- }
+++ inputPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- outputVector[number] =((float)(inputVector[number])) / scalar;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = ((float)(inputVector[number])) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void
++-volk_16i_s32f_convert_32f_u_sse4_1(float* outputVector, const int16_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16i_s32f_convert_32f_u_sse4_1(float* outputVector,
+++ const int16_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* outputVectorPtr = outputVector;
++- __m128 invScalar = _mm_set_ps1(1.0/scalar);
++- int16_t* inputPtr = (int16_t*)inputVector;
++- __m128i inputVal;
++- __m128i inputVal2;
++- __m128 ret;
+++ float* outputVectorPtr = outputVector;
+++ __m128 invScalar = _mm_set_ps1(1.0 / scalar);
+++ int16_t* inputPtr = (int16_t*)inputVector;
+++ __m128i inputVal;
+++ __m128i inputVal2;
+++ __m128 ret;
++
++- for(;number < eighthPoints; number++){
+++ for (; number < eighthPoints; number++) {
++
++- // Load the 8 values
++- inputVal = _mm_loadu_si128((__m128i*)inputPtr);
+++ // Load the 8 values
+++ inputVal = _mm_loadu_si128((__m128i*)inputPtr);
++
++- // Shift the input data to the right by 64 bits ( 8 bytes )
++- inputVal2 = _mm_srli_si128(inputVal, 8);
+++ // Shift the input data to the right by 64 bits ( 8 bytes )
+++ inputVal2 = _mm_srli_si128(inputVal, 8);
++
++- // Convert the lower 4 values into 32 bit words
++- inputVal = _mm_cvtepi16_epi32(inputVal);
++- inputVal2 = _mm_cvtepi16_epi32(inputVal2);
+++ // Convert the lower 4 values into 32 bit words
+++ inputVal = _mm_cvtepi16_epi32(inputVal);
+++ inputVal2 = _mm_cvtepi16_epi32(inputVal2);
++
++- ret = _mm_cvtepi32_ps(inputVal);
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_storeu_ps(outputVectorPtr, ret);
++- outputVectorPtr += 4;
+++ ret = _mm_cvtepi32_ps(inputVal);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_storeu_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 4;
++
++- ret = _mm_cvtepi32_ps(inputVal2);
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_storeu_ps(outputVectorPtr, ret);
+++ ret = _mm_cvtepi32_ps(inputVal2);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_storeu_ps(outputVectorPtr, ret);
++
++- outputVectorPtr += 4;
+++ outputVectorPtr += 4;
++
++- inputPtr += 8;
++- }
+++ inputPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- outputVector[number] =((float)(inputVector[number])) / scalar;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = ((float)(inputVector[number])) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_16i_s32f_convert_32f_u_sse(float* outputVector, const int16_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16i_s32f_convert_32f_u_sse(float* outputVector,
+++ const int16_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- float* outputVectorPtr = outputVector;
++- __m128 invScalar = _mm_set_ps1(1.0/scalar);
++- int16_t* inputPtr = (int16_t*)inputVector;
++- __m128 ret;
++-
++- for(;number < quarterPoints; number++){
++- ret = _mm_set_ps((float)(inputPtr[3]), (float)(inputPtr[2]), (float)(inputPtr[1]), (float)(inputPtr[0]));
++-
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_storeu_ps(outputVectorPtr, ret);
++-
++- inputPtr += 4;
++- outputVectorPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- outputVector[number] = (float)(inputVector[number]) / scalar;
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ float* outputVectorPtr = outputVector;
+++ __m128 invScalar = _mm_set_ps1(1.0 / scalar);
+++ int16_t* inputPtr = (int16_t*)inputVector;
+++ __m128 ret;
+++
+++ for (; number < quarterPoints; number++) {
+++ ret = _mm_set_ps((float)(inputPtr[3]),
+++ (float)(inputPtr[2]),
+++ (float)(inputPtr[1]),
+++ (float)(inputPtr[0]));
+++
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_storeu_ps(outputVectorPtr, ret);
+++
+++ inputPtr += 4;
+++ outputVectorPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (float)(inputVector[number]) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_16i_s32f_convert_32f_generic(float* outputVector, const int16_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16i_s32f_convert_32f_generic(float* outputVector,
+++ const int16_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* outputVectorPtr = outputVector;
++- const int16_t* inputVectorPtr = inputVector;
++- unsigned int number = 0;
+++ float* outputVectorPtr = outputVector;
+++ const int16_t* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((float)(*inputVectorPtr++)) / scalar;
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((float)(*inputVectorPtr++)) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_16i_s32f_convert_32f_neon(float* outputVector, const int16_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16i_s32f_convert_32f_neon(float* outputVector,
+++ const int16_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* outputPtr = outputVector;
++- const int16_t* inputPtr = inputVector;
++- unsigned int number = 0;
++- unsigned int eighth_points = num_points / 8;
++-
++- int16x4x2_t input16;
++- int32x4_t input32_0, input32_1;
++- float32x4_t input_float_0, input_float_1;
++- float32x4x2_t output_float;
++- float32x4_t inv_scale;
++-
++- inv_scale = vdupq_n_f32(1.0/scalar);
++-
++- // the generic disassembles to a 128-bit load
++- // and duplicates every instruction to operate on 64-bits
++- // at a time. This is only possible with lanes, which is faster
++- // than just doing a vld1_s16, but still slower.
++- for(number = 0; number < eighth_points; number++){
++- input16 = vld2_s16(inputPtr);
++- // widen 16-bit int to 32-bit int
++- input32_0 = vmovl_s16(input16.val[0]);
++- input32_1 = vmovl_s16(input16.val[1]);
++- // convert 32-bit int to float with scale
++- input_float_0 = vcvtq_f32_s32(input32_0);
++- input_float_1 = vcvtq_f32_s32(input32_1);
++- output_float.val[0] = vmulq_f32(input_float_0, inv_scale);
++- output_float.val[1] = vmulq_f32(input_float_1, inv_scale);
++- vst2q_f32(outputPtr, output_float);
++- inputPtr += 8;
++- outputPtr += 8;
++- }
++-
++- for(number = eighth_points*8; number < num_points; number++){
++- *outputPtr++ = ((float)(*inputPtr++)) / scalar;
++- }
+++ float* outputPtr = outputVector;
+++ const int16_t* inputPtr = inputVector;
+++ unsigned int number = 0;
+++ unsigned int eighth_points = num_points / 8;
+++
+++ int16x4x2_t input16;
+++ int32x4_t input32_0, input32_1;
+++ float32x4_t input_float_0, input_float_1;
+++ float32x4x2_t output_float;
+++ float32x4_t inv_scale;
+++
+++ inv_scale = vdupq_n_f32(1.0 / scalar);
+++
+++ // the generic disassembles to a 128-bit load
+++ // and duplicates every instruction to operate on 64-bits
+++ // at a time. This is only possible with lanes, which is faster
+++ // than just doing a vld1_s16, but still slower.
+++ for (number = 0; number < eighth_points; number++) {
+++ input16 = vld2_s16(inputPtr);
+++ // widen 16-bit int to 32-bit int
+++ input32_0 = vmovl_s16(input16.val[0]);
+++ input32_1 = vmovl_s16(input16.val[1]);
+++ // convert 32-bit int to float with scale
+++ input_float_0 = vcvtq_f32_s32(input32_0);
+++ input_float_1 = vcvtq_f32_s32(input32_1);
+++ output_float.val[0] = vmulq_f32(input_float_0, inv_scale);
+++ output_float.val[1] = vmulq_f32(input_float_1, inv_scale);
+++ vst2q_f32(outputPtr, output_float);
+++ inputPtr += 8;
+++ outputPtr += 8;
+++ }
+++
+++ for (number = eighth_points * 8; number < num_points; number++) {
+++ *outputPtr++ = ((float)(*inputPtr++)) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++@@ -306,193 +315,201 @@ volk_16i_s32f_convert_32f_neon(float* outputVector, const int16_t* inputVector,
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16i_s32f_convert_32f_a_avx2(float* outputVector, const int16_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16i_s32f_convert_32f_a_avx2(float* outputVector,
+++ const int16_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* outputVectorPtr = outputVector;
++- __m256 invScalar = _mm256_set1_ps(1.0/scalar);
++- int16_t* inputPtr = (int16_t*)inputVector;
++- __m128i inputVal;
++- __m256i inputVal2;
++- __m256 ret;
+++ float* outputVectorPtr = outputVector;
+++ __m256 invScalar = _mm256_set1_ps(1.0 / scalar);
+++ int16_t* inputPtr = (int16_t*)inputVector;
+++ __m128i inputVal;
+++ __m256i inputVal2;
+++ __m256 ret;
++
++- for(;number < eighthPoints; number++){
+++ for (; number < eighthPoints; number++) {
++
++- // Load the 8 values
++- inputVal = _mm_load_si128((__m128i*)inputPtr);
+++ // Load the 8 values
+++ inputVal = _mm_load_si128((__m128i*)inputPtr);
++
++- // Convert
++- inputVal2 = _mm256_cvtepi16_epi32(inputVal);
+++ // Convert
+++ inputVal2 = _mm256_cvtepi16_epi32(inputVal);
++
++- ret = _mm256_cvtepi32_ps(inputVal2);
++- ret = _mm256_mul_ps(ret, invScalar);
+++ ret = _mm256_cvtepi32_ps(inputVal2);
+++ ret = _mm256_mul_ps(ret, invScalar);
++
++- _mm256_store_ps(outputVectorPtr, ret);
+++ _mm256_store_ps(outputVectorPtr, ret);
++
++- outputVectorPtr += 8;
+++ outputVectorPtr += 8;
++
++- inputPtr += 8;
++- }
+++ inputPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- outputVector[number] =((float)(inputVector[number])) / scalar;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = ((float)(inputVector[number])) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_16i_s32f_convert_32f_a_avx(float* outputVector, const int16_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16i_s32f_convert_32f_a_avx(float* outputVector,
+++ const int16_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* outputVectorPtr = outputVector;
++- __m128 invScalar = _mm_set_ps1(1.0/scalar);
++- int16_t* inputPtr = (int16_t*)inputVector;
++- __m128i inputVal, inputVal2;
++- __m128 ret;
++- __m256 output;
++- __m256 dummy = _mm256_setzero_ps();
+++ float* outputVectorPtr = outputVector;
+++ __m128 invScalar = _mm_set_ps1(1.0 / scalar);
+++ int16_t* inputPtr = (int16_t*)inputVector;
+++ __m128i inputVal, inputVal2;
+++ __m128 ret;
+++ __m256 output;
+++ __m256 dummy = _mm256_setzero_ps();
++
++- for(;number < eighthPoints; number++){
+++ for (; number < eighthPoints; number++) {
++
++- // Load the 8 values
++- //inputVal = _mm_loadu_si128((__m128i*)inputPtr);
++- inputVal = _mm_load_si128((__m128i*)inputPtr);
+++ // Load the 8 values
+++ // inputVal = _mm_loadu_si128((__m128i*)inputPtr);
+++ inputVal = _mm_load_si128((__m128i*)inputPtr);
++
++- // Shift the input data to the right by 64 bits ( 8 bytes )
++- inputVal2 = _mm_srli_si128(inputVal, 8);
+++ // Shift the input data to the right by 64 bits ( 8 bytes )
+++ inputVal2 = _mm_srli_si128(inputVal, 8);
++
++- // Convert the lower 4 values into 32 bit words
++- inputVal = _mm_cvtepi16_epi32(inputVal);
++- inputVal2 = _mm_cvtepi16_epi32(inputVal2);
+++ // Convert the lower 4 values into 32 bit words
+++ inputVal = _mm_cvtepi16_epi32(inputVal);
+++ inputVal2 = _mm_cvtepi16_epi32(inputVal2);
++
++- ret = _mm_cvtepi32_ps(inputVal);
++- ret = _mm_mul_ps(ret, invScalar);
++- output = _mm256_insertf128_ps(dummy, ret, 0);
+++ ret = _mm_cvtepi32_ps(inputVal);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ output = _mm256_insertf128_ps(dummy, ret, 0);
++
++- ret = _mm_cvtepi32_ps(inputVal2);
++- ret = _mm_mul_ps(ret, invScalar);
++- output = _mm256_insertf128_ps(output, ret, 1);
+++ ret = _mm_cvtepi32_ps(inputVal2);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ output = _mm256_insertf128_ps(output, ret, 1);
++
++- _mm256_store_ps(outputVectorPtr, output);
+++ _mm256_store_ps(outputVectorPtr, output);
++
++- outputVectorPtr += 8;
+++ outputVectorPtr += 8;
++
++- inputPtr += 8;
++- }
+++ inputPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- outputVector[number] =((float)(inputVector[number])) / scalar;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = ((float)(inputVector[number])) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void
++-volk_16i_s32f_convert_32f_a_sse4_1(float* outputVector, const int16_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16i_s32f_convert_32f_a_sse4_1(float* outputVector,
+++ const int16_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* outputVectorPtr = outputVector;
++- __m128 invScalar = _mm_set_ps1(1.0/scalar);
++- int16_t* inputPtr = (int16_t*)inputVector;
++- __m128i inputVal;
++- __m128i inputVal2;
++- __m128 ret;
+++ float* outputVectorPtr = outputVector;
+++ __m128 invScalar = _mm_set_ps1(1.0 / scalar);
+++ int16_t* inputPtr = (int16_t*)inputVector;
+++ __m128i inputVal;
+++ __m128i inputVal2;
+++ __m128 ret;
++
++- for(;number < eighthPoints; number++){
+++ for (; number < eighthPoints; number++) {
++
++- // Load the 8 values
++- inputVal = _mm_loadu_si128((__m128i*)inputPtr);
+++ // Load the 8 values
+++ inputVal = _mm_loadu_si128((__m128i*)inputPtr);
++
++- // Shift the input data to the right by 64 bits ( 8 bytes )
++- inputVal2 = _mm_srli_si128(inputVal, 8);
+++ // Shift the input data to the right by 64 bits ( 8 bytes )
+++ inputVal2 = _mm_srli_si128(inputVal, 8);
++
++- // Convert the lower 4 values into 32 bit words
++- inputVal = _mm_cvtepi16_epi32(inputVal);
++- inputVal2 = _mm_cvtepi16_epi32(inputVal2);
+++ // Convert the lower 4 values into 32 bit words
+++ inputVal = _mm_cvtepi16_epi32(inputVal);
+++ inputVal2 = _mm_cvtepi16_epi32(inputVal2);
++
++- ret = _mm_cvtepi32_ps(inputVal);
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_storeu_ps(outputVectorPtr, ret);
++- outputVectorPtr += 4;
+++ ret = _mm_cvtepi32_ps(inputVal);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_storeu_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 4;
++
++- ret = _mm_cvtepi32_ps(inputVal2);
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_storeu_ps(outputVectorPtr, ret);
+++ ret = _mm_cvtepi32_ps(inputVal2);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_storeu_ps(outputVectorPtr, ret);
++
++- outputVectorPtr += 4;
+++ outputVectorPtr += 4;
++
++- inputPtr += 8;
++- }
+++ inputPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- outputVector[number] =((float)(inputVector[number])) / scalar;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = ((float)(inputVector[number])) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_16i_s32f_convert_32f_a_sse(float* outputVector, const int16_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16i_s32f_convert_32f_a_sse(float* outputVector,
+++ const int16_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- float* outputVectorPtr = outputVector;
++- __m128 invScalar = _mm_set_ps1(1.0/scalar);
++- int16_t* inputPtr = (int16_t*)inputVector;
++- __m128 ret;
++-
++- for(;number < quarterPoints; number++){
++- ret = _mm_set_ps((float)(inputPtr[3]), (float)(inputPtr[2]), (float)(inputPtr[1]), (float)(inputPtr[0]));
++-
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_storeu_ps(outputVectorPtr, ret);
++-
++- inputPtr += 4;
++- outputVectorPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- outputVector[number] = (float)(inputVector[number]) / scalar;
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ float* outputVectorPtr = outputVector;
+++ __m128 invScalar = _mm_set_ps1(1.0 / scalar);
+++ int16_t* inputPtr = (int16_t*)inputVector;
+++ __m128 ret;
+++
+++ for (; number < quarterPoints; number++) {
+++ ret = _mm_set_ps((float)(inputPtr[3]),
+++ (float)(inputPtr[2]),
+++ (float)(inputPtr[1]),
+++ (float)(inputPtr[0]));
+++
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_storeu_ps(outputVectorPtr, ret);
+++
+++ inputPtr += 4;
+++ outputVectorPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (float)(inputVector[number]) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_16i_s32f_convert_32f_a_generic(float* outputVector, const int16_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16i_s32f_convert_32f_a_generic(float* outputVector,
+++ const int16_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* outputVectorPtr = outputVector;
++- const int16_t* inputVectorPtr = inputVector;
++- unsigned int number = 0;
+++ float* outputVectorPtr = outputVector;
+++ const int16_t* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((float)(*inputVectorPtr++)) / scalar;
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((float)(*inputVectorPtr++)) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_16i_x4_quad_max_star_16i.h b/kernels/volk/volk_16i_x4_quad_max_star_16i.h
++index 6aa74c7..619cc90 100644
++--- a/kernels/volk/volk_16i_x4_quad_max_star_16i.h
+++++ b/kernels/volk/volk_16i_x4_quad_max_star_16i.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16i_x4_quad_max_star_16i(short* target, short* src0, short* src1, short* src2, short* src3, unsigned int num_points)
++- * \endcode
+++ * void volk_16i_x4_quad_max_star_16i(short* target, short* src0, short* src1, short*
+++ * src2, short* src3, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li src0: The input vector 0.
++@@ -55,149 +55,152 @@
++ #ifndef INCLUDED_volk_16i_x4_quad_max_star_16i_a_H
++ #define INCLUDED_volk_16i_x4_quad_max_star_16i_a_H
++
++-#include<inttypes.h>
++-#include<stdio.h>
+++#include <inttypes.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_SSE2
++
++-#include<emmintrin.h>
+++#include <emmintrin.h>
++
++-static inline void
++-volk_16i_x4_quad_max_star_16i_a_sse2(short* target, short* src0, short* src1,
++- short* src2, short* src3, unsigned int num_points)
+++static inline void volk_16i_x4_quad_max_star_16i_a_sse2(short* target,
+++ short* src0,
+++ short* src1,
+++ short* src2,
+++ short* src3,
+++ unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*2;
++-
++- int i = 0;
+++ const unsigned int num_bytes = num_points * 2;
++
++- int bound = (num_bytes >> 4);
++- int bound_copy = bound;
++- int leftovers = (num_bytes >> 1) & 7;
+++ int i = 0;
++
++- __m128i *p_target, *p_src0, *p_src1, *p_src2, *p_src3;
++- p_target = (__m128i*) target;
++- p_src0 = (__m128i*)src0;
++- p_src1 = (__m128i*)src1;
++- p_src2 = (__m128i*)src2;
++- p_src3 = (__m128i*)src3;
+++ int bound = (num_bytes >> 4);
+++ int bound_copy = bound;
+++ int leftovers = (num_bytes >> 1) & 7;
++
++- __m128i xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8;
+++ __m128i *p_target, *p_src0, *p_src1, *p_src2, *p_src3;
+++ p_target = (__m128i*)target;
+++ p_src0 = (__m128i*)src0;
+++ p_src1 = (__m128i*)src1;
+++ p_src2 = (__m128i*)src2;
+++ p_src3 = (__m128i*)src3;
++
++- while(bound_copy > 0) {
++- xmm1 = _mm_load_si128(p_src0);
++- xmm2 = _mm_load_si128(p_src1);
++- xmm3 = _mm_load_si128(p_src2);
++- xmm4 = _mm_load_si128(p_src3);
+++ __m128i xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8;
++
++- xmm5 = _mm_setzero_si128();
++- xmm6 = _mm_setzero_si128();
++- xmm7 = xmm1;
++- xmm8 = xmm3;
+++ while (bound_copy > 0) {
+++ xmm1 = _mm_load_si128(p_src0);
+++ xmm2 = _mm_load_si128(p_src1);
+++ xmm3 = _mm_load_si128(p_src2);
+++ xmm4 = _mm_load_si128(p_src3);
++
++- xmm1 = _mm_sub_epi16(xmm2, xmm1);
+++ xmm5 = _mm_setzero_si128();
+++ xmm6 = _mm_setzero_si128();
+++ xmm7 = xmm1;
+++ xmm8 = xmm3;
++
++- xmm3 = _mm_sub_epi16(xmm4, xmm3);
+++ xmm1 = _mm_sub_epi16(xmm2, xmm1);
++
++- xmm5 = _mm_cmpgt_epi16(xmm1, xmm5);
++- xmm6 = _mm_cmpgt_epi16(xmm3, xmm6);
+++ xmm3 = _mm_sub_epi16(xmm4, xmm3);
++
++- xmm2 = _mm_and_si128(xmm5, xmm2);
++- xmm4 = _mm_and_si128(xmm6, xmm4);
++- xmm5 = _mm_andnot_si128(xmm5, xmm7);
++- xmm6 = _mm_andnot_si128(xmm6, xmm8);
+++ xmm5 = _mm_cmpgt_epi16(xmm1, xmm5);
+++ xmm6 = _mm_cmpgt_epi16(xmm3, xmm6);
++
++- xmm5 = _mm_add_epi16(xmm2, xmm5);
++- xmm6 = _mm_add_epi16(xmm4, xmm6);
+++ xmm2 = _mm_and_si128(xmm5, xmm2);
+++ xmm4 = _mm_and_si128(xmm6, xmm4);
+++ xmm5 = _mm_andnot_si128(xmm5, xmm7);
+++ xmm6 = _mm_andnot_si128(xmm6, xmm8);
++
++- xmm1 = _mm_xor_si128(xmm1, xmm1);
++- xmm2 = xmm5;
++- xmm5 = _mm_sub_epi16(xmm6, xmm5);
++- p_src0 += 1;
++- bound_copy -= 1;
+++ xmm5 = _mm_add_epi16(xmm2, xmm5);
+++ xmm6 = _mm_add_epi16(xmm4, xmm6);
++
++- xmm1 = _mm_cmpgt_epi16(xmm5, xmm1);
++- p_src1 += 1;
+++ xmm1 = _mm_xor_si128(xmm1, xmm1);
+++ xmm2 = xmm5;
+++ xmm5 = _mm_sub_epi16(xmm6, xmm5);
+++ p_src0 += 1;
+++ bound_copy -= 1;
++
++- xmm6 = _mm_and_si128(xmm1, xmm6);
+++ xmm1 = _mm_cmpgt_epi16(xmm5, xmm1);
+++ p_src1 += 1;
++
++- xmm1 = _mm_andnot_si128(xmm1, xmm2);
++- p_src2 += 1;
+++ xmm6 = _mm_and_si128(xmm1, xmm6);
++
++- xmm1 = _mm_add_epi16(xmm6, xmm1);
++- p_src3 += 1;
+++ xmm1 = _mm_andnot_si128(xmm1, xmm2);
+++ p_src2 += 1;
++
++- _mm_store_si128(p_target, xmm1);
++- p_target += 1;
+++ xmm1 = _mm_add_epi16(xmm6, xmm1);
+++ p_src3 += 1;
++
++- }
+++ _mm_store_si128(p_target, xmm1);
+++ p_target += 1;
+++ }
++
++
++- /*__VOLK_ASM __VOLK_VOLATILE
++- (
++- "volk_16i_x4_quad_max_star_16i_a_sse2_L1:\n\t"
++- "cmp $0, %[bound]\n\t"
++- "je volk_16i_x4_quad_max_star_16i_a_sse2_END\n\t"
+++ /*__VOLK_ASM __VOLK_VOLATILE
+++ (
+++ "volk_16i_x4_quad_max_star_16i_a_sse2_L1:\n\t"
+++ "cmp $0, %[bound]\n\t"
+++ "je volk_16i_x4_quad_max_star_16i_a_sse2_END\n\t"
++
++- "movaps (%[src0]), %%xmm1\n\t"
++- "movaps (%[src1]), %%xmm2\n\t"
++- "movaps (%[src2]), %%xmm3\n\t"
++- "movaps (%[src3]), %%xmm4\n\t"
+++ "movaps (%[src0]), %%xmm1\n\t"
+++ "movaps (%[src1]), %%xmm2\n\t"
+++ "movaps (%[src2]), %%xmm3\n\t"
+++ "movaps (%[src3]), %%xmm4\n\t"
++
++- "pxor %%xmm5, %%xmm5\n\t"
++- "pxor %%xmm6, %%xmm6\n\t"
++- "movaps %%xmm1, %%xmm7\n\t"
++- "movaps %%xmm3, %%xmm8\n\t"
++- "psubw %%xmm2, %%xmm1\n\t"
++- "psubw %%xmm4, %%xmm3\n\t"
+++ "pxor %%xmm5, %%xmm5\n\t"
+++ "pxor %%xmm6, %%xmm6\n\t"
+++ "movaps %%xmm1, %%xmm7\n\t"
+++ "movaps %%xmm3, %%xmm8\n\t"
+++ "psubw %%xmm2, %%xmm1\n\t"
+++ "psubw %%xmm4, %%xmm3\n\t"
++
++- "pcmpgtw %%xmm1, %%xmm5\n\t"
++- "pcmpgtw %%xmm3, %%xmm6\n\t"
+++ "pcmpgtw %%xmm1, %%xmm5\n\t"
+++ "pcmpgtw %%xmm3, %%xmm6\n\t"
++
++- "pand %%xmm5, %%xmm2\n\t"
++- "pand %%xmm6, %%xmm4\n\t"
++- "pandn %%xmm7, %%xmm5\n\t"
++- "pandn %%xmm8, %%xmm6\n\t"
+++ "pand %%xmm5, %%xmm2\n\t"
+++ "pand %%xmm6, %%xmm4\n\t"
+++ "pandn %%xmm7, %%xmm5\n\t"
+++ "pandn %%xmm8, %%xmm6\n\t"
++
++- "paddw %%xmm2, %%xmm5\n\t"
++- "paddw %%xmm4, %%xmm6\n\t"
+++ "paddw %%xmm2, %%xmm5\n\t"
+++ "paddw %%xmm4, %%xmm6\n\t"
++
++- "pxor %%xmm1, %%xmm1\n\t"
++- "movaps %%xmm5, %%xmm2\n\t"
+++ "pxor %%xmm1, %%xmm1\n\t"
+++ "movaps %%xmm5, %%xmm2\n\t"
++
++- "psubw %%xmm6, %%xmm5\n\t"
++- "add $16, %[src0]\n\t"
++- "add $-1, %[bound]\n\t"
+++ "psubw %%xmm6, %%xmm5\n\t"
+++ "add $16, %[src0]\n\t"
+++ "add $-1, %[bound]\n\t"
++
++- "pcmpgtw %%xmm5, %%xmm1\n\t"
++- "add $16, %[src1]\n\t"
+++ "pcmpgtw %%xmm5, %%xmm1\n\t"
+++ "add $16, %[src1]\n\t"
++
++- "pand %%xmm1, %%xmm6\n\t"
+++ "pand %%xmm1, %%xmm6\n\t"
++
++- "pandn %%xmm2, %%xmm1\n\t"
++- "add $16, %[src2]\n\t"
+++ "pandn %%xmm2, %%xmm1\n\t"
+++ "add $16, %[src2]\n\t"
++
++- "paddw %%xmm6, %%xmm1\n\t"
++- "add $16, %[src3]\n\t"
+++ "paddw %%xmm6, %%xmm1\n\t"
+++ "add $16, %[src3]\n\t"
++
++- "movaps %%xmm1, (%[target])\n\t"
++- "addw $16, %[target]\n\t"
++- "jmp volk_16i_x4_quad_max_star_16i_a_sse2_L1\n\t"
+++ "movaps %%xmm1, (%[target])\n\t"
+++ "addw $16, %[target]\n\t"
+++ "jmp volk_16i_x4_quad_max_star_16i_a_sse2_L1\n\t"
++
++- "volk_16i_x4_quad_max_star_16i_a_sse2_END:\n\t"
++- :
++- :[bound]"r"(bound), [src0]"r"(src0), [src1]"r"(src1), [src2]"r"(src2), [src3]"r"(src3), [target]"r"(target)
++- :
++- );
++- */
+++ "volk_16i_x4_quad_max_star_16i_a_sse2_END:\n\t"
+++ :
+++ :[bound]"r"(bound), [src0]"r"(src0), [src1]"r"(src1), [src2]"r"(src2),
+++ [src3]"r"(src3), [target]"r"(target)
+++ :
+++ );
+++ */
++
++- short temp0 = 0;
++- short temp1 = 0;
++- for(i = bound * 8; i < (bound * 8) + leftovers; ++i) {
++- temp0 = ((short)(src0[i] - src1[i]) > 0) ? src0[i] : src1[i];
++- temp1 = ((short)(src2[i] - src3[i])>0) ? src2[i] : src3[i];
++- target[i] = ((short)(temp0 - temp1)>0) ? temp0 : temp1;
++- }
++- return;
+++ short temp0 = 0;
+++ short temp1 = 0;
+++ for (i = bound * 8; i < (bound * 8) + leftovers; ++i) {
+++ temp0 = ((short)(src0[i] - src1[i]) > 0) ? src0[i] : src1[i];
+++ temp1 = ((short)(src2[i] - src3[i]) > 0) ? src2[i] : src3[i];
+++ target[i] = ((short)(temp0 - temp1) > 0) ? temp0 : temp1;
+++ }
+++ return;
++ }
++
++ #endif /*LV_HAVE_SSE2*/
++@@ -206,85 +209,91 @@ volk_16i_x4_quad_max_star_16i_a_sse2(short* target, short* src0, short* src1,
++
++ #include <arm_neon.h>
++
++-static inline void
++-volk_16i_x4_quad_max_star_16i_neon(short* target, short* src0, short* src1,
++- short* src2, short* src3, unsigned int num_points)
+++static inline void volk_16i_x4_quad_max_star_16i_neon(short* target,
+++ short* src0,
+++ short* src1,
+++ short* src2,
+++ short* src3,
+++ unsigned int num_points)
++ {
++- const unsigned int eighth_points = num_points / 8;
++- unsigned i;
++-
++- int16x8_t src0_vec, src1_vec, src2_vec, src3_vec;
++- int16x8_t diff12, diff34;
++- int16x8_t comp0, comp1, comp2, comp3;
++- int16x8_t result1_vec, result2_vec;
++- int16x8_t zeros;
++- zeros = vdupq_n_s16(0);
++- for(i=0; i < eighth_points; ++i) {
++- src0_vec = vld1q_s16(src0);
++- src1_vec = vld1q_s16(src1);
++- src2_vec = vld1q_s16(src2);
++- src3_vec = vld1q_s16(src3);
++- diff12 = vsubq_s16(src0_vec, src1_vec);
++- diff34 = vsubq_s16(src2_vec, src3_vec);
++- comp0 = (int16x8_t)vcgeq_s16(diff12, zeros);
++- comp1 = (int16x8_t)vcltq_s16(diff12, zeros);
++- comp2 = (int16x8_t)vcgeq_s16(diff34, zeros);
++- comp3 = (int16x8_t)vcltq_s16(diff34, zeros);
++- comp0 = vandq_s16(src0_vec, comp0);
++- comp1 = vandq_s16(src1_vec, comp1);
++- comp2 = vandq_s16(src2_vec, comp2);
++- comp3 = vandq_s16(src3_vec, comp3);
++-
++- result1_vec = vaddq_s16(comp0, comp1);
++- result2_vec = vaddq_s16(comp2, comp3);
++-
++- diff12 = vsubq_s16(result1_vec, result2_vec);
++- comp0 = (int16x8_t)vcgeq_s16(diff12, zeros);
++- comp1 = (int16x8_t)vcltq_s16(diff12, zeros);
++- comp0 = vandq_s16(result1_vec, comp0);
++- comp1 = vandq_s16(result2_vec, comp1);
++- result1_vec = vaddq_s16(comp0, comp1);
++- vst1q_s16(target, result1_vec);
++- src0 += 8;
++- src1 += 8;
++- src2 += 8;
++- src3 += 8;
++- target += 8;
+++ const unsigned int eighth_points = num_points / 8;
+++ unsigned i;
+++
+++ int16x8_t src0_vec, src1_vec, src2_vec, src3_vec;
+++ int16x8_t diff12, diff34;
+++ int16x8_t comp0, comp1, comp2, comp3;
+++ int16x8_t result1_vec, result2_vec;
+++ int16x8_t zeros;
+++ zeros = vdupq_n_s16(0);
+++ for (i = 0; i < eighth_points; ++i) {
+++ src0_vec = vld1q_s16(src0);
+++ src1_vec = vld1q_s16(src1);
+++ src2_vec = vld1q_s16(src2);
+++ src3_vec = vld1q_s16(src3);
+++ diff12 = vsubq_s16(src0_vec, src1_vec);
+++ diff34 = vsubq_s16(src2_vec, src3_vec);
+++ comp0 = (int16x8_t)vcgeq_s16(diff12, zeros);
+++ comp1 = (int16x8_t)vcltq_s16(diff12, zeros);
+++ comp2 = (int16x8_t)vcgeq_s16(diff34, zeros);
+++ comp3 = (int16x8_t)vcltq_s16(diff34, zeros);
+++ comp0 = vandq_s16(src0_vec, comp0);
+++ comp1 = vandq_s16(src1_vec, comp1);
+++ comp2 = vandq_s16(src2_vec, comp2);
+++ comp3 = vandq_s16(src3_vec, comp3);
+++
+++ result1_vec = vaddq_s16(comp0, comp1);
+++ result2_vec = vaddq_s16(comp2, comp3);
+++
+++ diff12 = vsubq_s16(result1_vec, result2_vec);
+++ comp0 = (int16x8_t)vcgeq_s16(diff12, zeros);
+++ comp1 = (int16x8_t)vcltq_s16(diff12, zeros);
+++ comp0 = vandq_s16(result1_vec, comp0);
+++ comp1 = vandq_s16(result2_vec, comp1);
+++ result1_vec = vaddq_s16(comp0, comp1);
+++ vst1q_s16(target, result1_vec);
+++ src0 += 8;
+++ src1 += 8;
+++ src2 += 8;
+++ src3 += 8;
+++ target += 8;
++ }
++
++- short temp0 = 0;
++- short temp1 = 0;
++- for(i=eighth_points*8; i < num_points; ++i) {
++- temp0 = ((short)(*src0 - *src1) > 0) ? *src0 : *src1;
++- temp1 = ((short)(*src2 - *src3) > 0) ? *src2 : *src3;
++- *target++ = ((short)(temp0 - temp1)>0) ? temp0 : temp1;
++- src0++;
++- src1++;
++- src2++;
++- src3++;
++- }
+++ short temp0 = 0;
+++ short temp1 = 0;
+++ for (i = eighth_points * 8; i < num_points; ++i) {
+++ temp0 = ((short)(*src0 - *src1) > 0) ? *src0 : *src1;
+++ temp1 = ((short)(*src2 - *src3) > 0) ? *src2 : *src3;
+++ *target++ = ((short)(temp0 - temp1) > 0) ? temp0 : temp1;
+++ src0++;
+++ src1++;
+++ src2++;
+++ src3++;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void
++-volk_16i_x4_quad_max_star_16i_generic(short* target, short* src0, short* src1,
++- short* src2, short* src3, unsigned int num_points)
+++static inline void volk_16i_x4_quad_max_star_16i_generic(short* target,
+++ short* src0,
+++ short* src1,
+++ short* src2,
+++ short* src3,
+++ unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*2;
+++ const unsigned int num_bytes = num_points * 2;
++
++- int i = 0;
+++ int i = 0;
++
++- int bound = num_bytes >> 1;
+++ int bound = num_bytes >> 1;
++
++- short temp0 = 0;
++- short temp1 = 0;
++- for(i = 0; i < bound; ++i) {
++- temp0 = ((short)(src0[i] - src1[i]) > 0) ? src0[i] : src1[i];
++- temp1 = ((short)(src2[i] - src3[i])>0) ? src2[i] : src3[i];
++- target[i] = ((short)(temp0 - temp1)>0) ? temp0 : temp1;
++- }
+++ short temp0 = 0;
+++ short temp1 = 0;
+++ for (i = 0; i < bound; ++i) {
+++ temp0 = ((short)(src0[i] - src1[i]) > 0) ? src0[i] : src1[i];
+++ temp1 = ((short)(src2[i] - src3[i]) > 0) ? src2[i] : src3[i];
+++ target[i] = ((short)(temp0 - temp1) > 0) ? temp0 : temp1;
+++ }
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++diff --git a/kernels/volk/volk_16i_x5_add_quad_16i_x4.h b/kernels/volk/volk_16i_x5_add_quad_16i_x4.h
++index 30417de..f735f11 100644
++--- a/kernels/volk/volk_16i_x5_add_quad_16i_x4.h
+++++ b/kernels/volk/volk_16i_x5_add_quad_16i_x4.h
++@@ -29,8 +29,9 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16i_x5_add_quad_16i_x4(short* target0, short* target1, short* target2, short* target3, short* src0, short* src1, short* src2, short* src3, short* src4, unsigned int num_points);
++- * \endcode
+++ * void volk_16i_x5_add_quad_16i_x4(short* target0, short* target1, short* target2, short*
+++ * target3, short* src0, short* src1, short* src2, short* src3, short* src4, unsigned int
+++ * num_points); \endcode
++ *
++ * \b Inputs
++ * \li src0: The input vector 0.
++@@ -59,182 +60,203 @@
++ #ifndef INCLUDED_volk_16i_x5_add_quad_16i_x4_a_H
++ #define INCLUDED_volk_16i_x5_add_quad_16i_x4_a_H
++
++-#include<inttypes.h>
++-#include<stdio.h>
+++#include <inttypes.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_SSE2
++-#include<xmmintrin.h>
++-#include<emmintrin.h>
+++#include <emmintrin.h>
+++#include <xmmintrin.h>
++
++-static inline void
++-volk_16i_x5_add_quad_16i_x4_a_sse2(short* target0, short* target1, short* target2, short* target3,
++- short* src0, short* src1, short* src2, short* src3, short* src4,
++- unsigned int num_points)
+++static inline void volk_16i_x5_add_quad_16i_x4_a_sse2(short* target0,
+++ short* target1,
+++ short* target2,
+++ short* target3,
+++ short* src0,
+++ short* src1,
+++ short* src2,
+++ short* src3,
+++ short* src4,
+++ unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*2;
++-
++- __m128i xmm0, xmm1, xmm2, xmm3, xmm4;
++- __m128i *p_target0, *p_target1, *p_target2, *p_target3, *p_src0, *p_src1, *p_src2, *p_src3, *p_src4;
++- p_target0 = (__m128i*)target0;
++- p_target1 = (__m128i*)target1;
++- p_target2 = (__m128i*)target2;
++- p_target3 = (__m128i*)target3;
++-
++- p_src0 = (__m128i*)src0;
++- p_src1 = (__m128i*)src1;
++- p_src2 = (__m128i*)src2;
++- p_src3 = (__m128i*)src3;
++- p_src4 = (__m128i*)src4;
++-
++- int i = 0;
++-
++- int bound = (num_bytes >> 4);
++- int leftovers = (num_bytes >> 1) & 7;
++-
++- for(; i < bound; ++i) {
++- xmm0 = _mm_load_si128(p_src0);
++- xmm1 = _mm_load_si128(p_src1);
++- xmm2 = _mm_load_si128(p_src2);
++- xmm3 = _mm_load_si128(p_src3);
++- xmm4 = _mm_load_si128(p_src4);
++-
++- p_src0 += 1;
++- p_src1 += 1;
++-
++- xmm1 = _mm_add_epi16(xmm0, xmm1);
++- xmm2 = _mm_add_epi16(xmm0, xmm2);
++- xmm3 = _mm_add_epi16(xmm0, xmm3);
++- xmm4 = _mm_add_epi16(xmm0, xmm4);
++-
++-
++- p_src2 += 1;
++- p_src3 += 1;
++- p_src4 += 1;
++-
++- _mm_store_si128(p_target0, xmm1);
++- _mm_store_si128(p_target1, xmm2);
++- _mm_store_si128(p_target2, xmm3);
++- _mm_store_si128(p_target3, xmm4);
++-
++- p_target0 += 1;
++- p_target1 += 1;
++- p_target2 += 1;
++- p_target3 += 1;
++- }
++- /*__VOLK_ASM __VOLK_VOLATILE
++- (
++- ".%=volk_16i_x5_add_quad_16i_x4_a_sse2_L1:\n\t"
++- "cmp $0, %[bound]\n\t"
++- "je .%=volk_16i_x5_add_quad_16i_x4_a_sse2_END\n\t"
++- "movaps (%[src0]), %%xmm1\n\t"
++- "movaps (%[src1]), %%xmm2\n\t"
++- "movaps (%[src2]), %%xmm3\n\t"
++- "movaps (%[src3]), %%xmm4\n\t"
++- "movaps (%[src4]), %%xmm5\n\t"
++- "add $16, %[src0]\n\t"
++- "add $16, %[src1]\n\t"
++- "add $16, %[src2]\n\t"
++- "add $16, %[src3]\n\t"
++- "add $16, %[src4]\n\t"
++- "paddw %%xmm1, %%xmm2\n\t"
++- "paddw %%xmm1, %%xmm3\n\t"
++- "paddw %%xmm1, %%xmm4\n\t"
++- "paddw %%xmm1, %%xmm5\n\t"
++- "add $-1, %[bound]\n\t"
++- "movaps %%xmm2, (%[target0])\n\t"
++- "movaps %%xmm3, (%[target1])\n\t"
++- "movaps %%xmm4, (%[target2])\n\t"
++- "movaps %%xmm5, (%[target3])\n\t"
++- "add $16, %[target0]\n\t"
++- "add $16, %[target1]\n\t"
++- "add $16, %[target2]\n\t"
++- "add $16, %[target3]\n\t"
++- "jmp .%=volk_16i_x5_add_quad_16i_x4_a_sse2_L1\n\t"
++- ".%=volk_16i_x5_add_quad_16i_x4_a_sse2_END:\n\t"
++- :
++- :[bound]"r"(bound), [src0]"r"(src0), [src1]"r"(src1), [src2]"r"(src2), [src3]"r"(src3), [src4]"r"(src4), [target0]"r"(target0), [target1]"r"(target1), [target2]"r"(target2), [target3]"r"(target3)
++- :"xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
++- );
++- */
++-
++- for(i = bound * 8; i < (bound * 8) + leftovers; ++i) {
++- target0[i] = src0[i] + src1[i];
++- target1[i] = src0[i] + src2[i];
++- target2[i] = src0[i] + src3[i];
++- target3[i] = src0[i] + src4[i];
++- }
+++ const unsigned int num_bytes = num_points * 2;
+++
+++ __m128i xmm0, xmm1, xmm2, xmm3, xmm4;
+++ __m128i *p_target0, *p_target1, *p_target2, *p_target3, *p_src0, *p_src1, *p_src2,
+++ *p_src3, *p_src4;
+++ p_target0 = (__m128i*)target0;
+++ p_target1 = (__m128i*)target1;
+++ p_target2 = (__m128i*)target2;
+++ p_target3 = (__m128i*)target3;
+++
+++ p_src0 = (__m128i*)src0;
+++ p_src1 = (__m128i*)src1;
+++ p_src2 = (__m128i*)src2;
+++ p_src3 = (__m128i*)src3;
+++ p_src4 = (__m128i*)src4;
+++
+++ int i = 0;
+++
+++ int bound = (num_bytes >> 4);
+++ int leftovers = (num_bytes >> 1) & 7;
+++
+++ for (; i < bound; ++i) {
+++ xmm0 = _mm_load_si128(p_src0);
+++ xmm1 = _mm_load_si128(p_src1);
+++ xmm2 = _mm_load_si128(p_src2);
+++ xmm3 = _mm_load_si128(p_src3);
+++ xmm4 = _mm_load_si128(p_src4);
+++
+++ p_src0 += 1;
+++ p_src1 += 1;
+++
+++ xmm1 = _mm_add_epi16(xmm0, xmm1);
+++ xmm2 = _mm_add_epi16(xmm0, xmm2);
+++ xmm3 = _mm_add_epi16(xmm0, xmm3);
+++ xmm4 = _mm_add_epi16(xmm0, xmm4);
+++
+++
+++ p_src2 += 1;
+++ p_src3 += 1;
+++ p_src4 += 1;
+++
+++ _mm_store_si128(p_target0, xmm1);
+++ _mm_store_si128(p_target1, xmm2);
+++ _mm_store_si128(p_target2, xmm3);
+++ _mm_store_si128(p_target3, xmm4);
+++
+++ p_target0 += 1;
+++ p_target1 += 1;
+++ p_target2 += 1;
+++ p_target3 += 1;
+++ }
+++ /*__VOLK_ASM __VOLK_VOLATILE
+++ (
+++ ".%=volk_16i_x5_add_quad_16i_x4_a_sse2_L1:\n\t"
+++ "cmp $0, %[bound]\n\t"
+++ "je .%=volk_16i_x5_add_quad_16i_x4_a_sse2_END\n\t"
+++ "movaps (%[src0]), %%xmm1\n\t"
+++ "movaps (%[src1]), %%xmm2\n\t"
+++ "movaps (%[src2]), %%xmm3\n\t"
+++ "movaps (%[src3]), %%xmm4\n\t"
+++ "movaps (%[src4]), %%xmm5\n\t"
+++ "add $16, %[src0]\n\t"
+++ "add $16, %[src1]\n\t"
+++ "add $16, %[src2]\n\t"
+++ "add $16, %[src3]\n\t"
+++ "add $16, %[src4]\n\t"
+++ "paddw %%xmm1, %%xmm2\n\t"
+++ "paddw %%xmm1, %%xmm3\n\t"
+++ "paddw %%xmm1, %%xmm4\n\t"
+++ "paddw %%xmm1, %%xmm5\n\t"
+++ "add $-1, %[bound]\n\t"
+++ "movaps %%xmm2, (%[target0])\n\t"
+++ "movaps %%xmm3, (%[target1])\n\t"
+++ "movaps %%xmm4, (%[target2])\n\t"
+++ "movaps %%xmm5, (%[target3])\n\t"
+++ "add $16, %[target0]\n\t"
+++ "add $16, %[target1]\n\t"
+++ "add $16, %[target2]\n\t"
+++ "add $16, %[target3]\n\t"
+++ "jmp .%=volk_16i_x5_add_quad_16i_x4_a_sse2_L1\n\t"
+++ ".%=volk_16i_x5_add_quad_16i_x4_a_sse2_END:\n\t"
+++ :
+++ :[bound]"r"(bound), [src0]"r"(src0), [src1]"r"(src1), [src2]"r"(src2),
+++ [src3]"r"(src3), [src4]"r"(src4), [target0]"r"(target0), [target1]"r"(target1),
+++ [target2]"r"(target2), [target3]"r"(target3)
+++ :"xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
+++ );
+++ */
+++
+++ for (i = bound * 8; i < (bound * 8) + leftovers; ++i) {
+++ target0[i] = src0[i] + src1[i];
+++ target1[i] = src0[i] + src2[i];
+++ target2[i] = src0[i] + src3[i];
+++ target3[i] = src0[i] + src4[i];
+++ }
++ }
++ #endif /*LV_HAVE_SSE2*/
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_16i_x5_add_quad_16i_x4_neon(short* target0, short* target1, short* target2, short* target3,
++- short* src0, short* src1, short* src2, short* src3, short* src4,
++- unsigned int num_points)
+++static inline void volk_16i_x5_add_quad_16i_x4_neon(short* target0,
+++ short* target1,
+++ short* target2,
+++ short* target3,
+++ short* src0,
+++ short* src1,
+++ short* src2,
+++ short* src3,
+++ short* src4,
+++ unsigned int num_points)
++ {
++- const unsigned int eighth_points = num_points / 8;
++- unsigned int number = 0;
++-
++- int16x8_t src0_vec, src1_vec, src2_vec, src3_vec, src4_vec;
++- int16x8_t target0_vec, target1_vec, target2_vec, target3_vec;
++- for(number = 0; number < eighth_points; ++number) {
++- src0_vec = vld1q_s16(src0);
++- src1_vec = vld1q_s16(src1);
++- src2_vec = vld1q_s16(src2);
++- src3_vec = vld1q_s16(src3);
++- src4_vec = vld1q_s16(src4);
++-
++- target0_vec = vaddq_s16(src0_vec , src1_vec);
++- target1_vec = vaddq_s16(src0_vec , src2_vec);
++- target2_vec = vaddq_s16(src0_vec , src3_vec);
++- target3_vec = vaddq_s16(src0_vec , src4_vec);
++-
++- vst1q_s16(target0, target0_vec);
++- vst1q_s16(target1, target1_vec);
++- vst1q_s16(target2, target2_vec);
++- vst1q_s16(target3, target3_vec);
++- src0 += 8;
++- src1 += 8;
++- src2 += 8;
++- src3 += 8;
++- src4 += 8;
++- target0 += 8;
++- target1 += 8;
++- target2 += 8;
++- target3 += 8;
++- }
++-
++- for(number = eighth_points * 8; number < num_points; ++number) {
++- *target0++ = *src0 + *src1++;
++- *target1++ = *src0 + *src2++;
++- *target2++ = *src0 + *src3++;
++- *target3++ = *src0++ + *src4++;
++- }
+++ const unsigned int eighth_points = num_points / 8;
+++ unsigned int number = 0;
+++
+++ int16x8_t src0_vec, src1_vec, src2_vec, src3_vec, src4_vec;
+++ int16x8_t target0_vec, target1_vec, target2_vec, target3_vec;
+++ for (number = 0; number < eighth_points; ++number) {
+++ src0_vec = vld1q_s16(src0);
+++ src1_vec = vld1q_s16(src1);
+++ src2_vec = vld1q_s16(src2);
+++ src3_vec = vld1q_s16(src3);
+++ src4_vec = vld1q_s16(src4);
+++
+++ target0_vec = vaddq_s16(src0_vec, src1_vec);
+++ target1_vec = vaddq_s16(src0_vec, src2_vec);
+++ target2_vec = vaddq_s16(src0_vec, src3_vec);
+++ target3_vec = vaddq_s16(src0_vec, src4_vec);
+++
+++ vst1q_s16(target0, target0_vec);
+++ vst1q_s16(target1, target1_vec);
+++ vst1q_s16(target2, target2_vec);
+++ vst1q_s16(target3, target3_vec);
+++ src0 += 8;
+++ src1 += 8;
+++ src2 += 8;
+++ src3 += 8;
+++ src4 += 8;
+++ target0 += 8;
+++ target1 += 8;
+++ target2 += 8;
+++ target3 += 8;
+++ }
+++
+++ for (number = eighth_points * 8; number < num_points; ++number) {
+++ *target0++ = *src0 + *src1++;
+++ *target1++ = *src0 + *src2++;
+++ *target2++ = *src0 + *src3++;
+++ *target3++ = *src0++ + *src4++;
+++ }
++ }
++
++ #endif /* LV_HAVE_NEON */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_16i_x5_add_quad_16i_x4_generic(short* target0, short* target1, short* target2, short* target3,
++- short* src0, short* src1, short* src2, short* src3, short* src4,
++- unsigned int num_points)
+++static inline void volk_16i_x5_add_quad_16i_x4_generic(short* target0,
+++ short* target1,
+++ short* target2,
+++ short* target3,
+++ short* src0,
+++ short* src1,
+++ short* src2,
+++ short* src3,
+++ short* src4,
+++ unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*2;
+++ const unsigned int num_bytes = num_points * 2;
++
++- int i = 0;
+++ int i = 0;
++
++- int bound = num_bytes >> 1;
+++ int bound = num_bytes >> 1;
++
++- for(i = 0; i < bound; ++i) {
++- target0[i] = src0[i] + src1[i];
++- target1[i] = src0[i] + src2[i];
++- target2[i] = src0[i] + src3[i];
++- target3[i] = src0[i] + src4[i];
++- }
+++ for (i = 0; i < bound; ++i) {
+++ target0[i] = src0[i] + src1[i];
+++ target1[i] = src0[i] + src2[i];
+++ target2[i] = src0[i] + src3[i];
+++ target3[i] = src0[i] + src4[i];
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++diff --git a/kernels/volk/volk_16ic_convert_32fc.h b/kernels/volk/volk_16ic_convert_32fc.h
++index 84f067c..1453724 100644
++--- a/kernels/volk/volk_16ic_convert_32fc.h
+++++ b/kernels/volk/volk_16ic_convert_32fc.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16ic_convert_32fc(lv_32fc_t* outputVector, const lv_16sc_t* inputVector, unsigned int num_points)
++- * \endcode
+++ * void volk_16ic_convert_32fc(lv_32fc_t* outputVector, const lv_16sc_t* inputVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li inputVector: The complex 16-bit integer input data buffer.
++@@ -51,7 +51,9 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void volk_16ic_convert_32fc_a_avx2(lv_32fc_t* outputVector, const lv_16sc_t* inputVector, unsigned int num_points)
+++static inline void volk_16ic_convert_32fc_a_avx2(lv_32fc_t* outputVector,
+++ const lv_16sc_t* inputVector,
+++ unsigned int num_points)
++ {
++ const unsigned int avx_iters = num_points / 8;
++ unsigned int number = 0;
++@@ -61,36 +63,36 @@ static inline void volk_16ic_convert_32fc_a_avx2(lv_32fc_t* outputVector, const
++ __m256i outValInt;
++ __m128i cplxValue;
++
++- for(number = 0; number < avx_iters; number++)
++- {
++- cplxValue = _mm_load_si128((__m128i*)complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- outValInt = _mm256_cvtepi16_epi32(cplxValue);
++- outVal = _mm256_cvtepi32_ps(outValInt);
++- _mm256_store_ps((float*)outputVectorPtr, outVal);
+++ for (number = 0; number < avx_iters; number++) {
+++ cplxValue = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- outputVectorPtr += 8;
++- }
+++ outValInt = _mm256_cvtepi16_epi32(cplxValue);
+++ outVal = _mm256_cvtepi32_ps(outValInt);
+++ _mm256_store_ps((float*)outputVectorPtr, outVal);
+++
+++ outputVectorPtr += 8;
+++ }
++
++ number = avx_iters * 8;
++- for(; number < num_points*2; number++)
++- {
++- *outputVectorPtr++ = (float)*complexVectorPtr++;
++- }
+++ for (; number < num_points * 2; number++) {
+++ *outputVectorPtr++ = (float)*complexVectorPtr++;
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_16ic_convert_32fc_generic(lv_32fc_t* outputVector, const lv_16sc_t* inputVector, unsigned int num_points)
+++static inline void volk_16ic_convert_32fc_generic(lv_32fc_t* outputVector,
+++ const lv_16sc_t* inputVector,
+++ unsigned int num_points)
++ {
++ unsigned int i;
++- for(i = 0; i < num_points; i++)
++- {
++- outputVector[i] = lv_cmake((float)lv_creal(inputVector[i]), (float)lv_cimag(inputVector[i]));
++- }
+++ for (i = 0; i < num_points; i++) {
+++ outputVector[i] =
+++ lv_cmake((float)lv_creal(inputVector[i]), (float)lv_cimag(inputVector[i]));
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -99,7 +101,9 @@ static inline void volk_16ic_convert_32fc_generic(lv_32fc_t* outputVector, const
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_16ic_convert_32fc_a_sse2(lv_32fc_t* outputVector, const lv_16sc_t* inputVector, unsigned int num_points)
+++static inline void volk_16ic_convert_32fc_a_sse2(lv_32fc_t* outputVector,
+++ const lv_16sc_t* inputVector,
+++ unsigned int num_points)
++ {
++ const unsigned int sse_iters = num_points / 2;
++
++@@ -108,18 +112,21 @@ static inline void volk_16ic_convert_32fc_a_sse2(lv_32fc_t* outputVector, const
++ __m128 a;
++ unsigned int number;
++
++- for(number = 0; number < sse_iters; number++)
++- {
++- a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
++- _mm_store_ps((float*)_out, a);
++- _in += 2;
++- _out += 2;
++- }
++- if (num_points & 1)
++- {
++- *_out++ = lv_cmake((float)lv_creal(*_in), (float)lv_cimag(*_in));
++- _in++;
++- }
+++ for (number = 0; number < sse_iters; number++) {
+++ a = _mm_set_ps(
+++ (float)(lv_cimag(_in[1])),
+++ (float)(lv_creal(_in[1])),
+++ (float)(lv_cimag(_in[0])),
+++ (float)(lv_creal(
+++ _in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+++ _mm_store_ps((float*)_out, a);
+++ _in += 2;
+++ _out += 2;
+++ }
+++ if (num_points & 1) {
+++ *_out++ = lv_cmake((float)lv_creal(*_in), (float)lv_cimag(*_in));
+++ _in++;
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE2 */
++@@ -127,7 +134,9 @@ static inline void volk_16ic_convert_32fc_a_sse2(lv_32fc_t* outputVector, const
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_16ic_convert_32fc_a_avx(lv_32fc_t* outputVector, const lv_16sc_t* inputVector, unsigned int num_points)
+++static inline void volk_16ic_convert_32fc_a_avx(lv_32fc_t* outputVector,
+++ const lv_16sc_t* inputVector,
+++ unsigned int num_points)
++ {
++ const unsigned int sse_iters = num_points / 4;
++
++@@ -136,19 +145,26 @@ static inline void volk_16ic_convert_32fc_a_avx(lv_32fc_t* outputVector, const l
++ __m256 a;
++ unsigned int i, number;
++
++- for(number = 0; number < sse_iters; number++)
++- {
++- a = _mm256_set_ps((float)(lv_cimag(_in[3])), (float)(lv_creal(_in[3])), (float)(lv_cimag(_in[2])), (float)(lv_creal(_in[2])), (float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
++- _mm256_store_ps((float*)_out, a);
++- _in += 4;
++- _out += 4;
++- }
+++ for (number = 0; number < sse_iters; number++) {
+++ a = _mm256_set_ps(
+++ (float)(lv_cimag(_in[3])),
+++ (float)(lv_creal(_in[3])),
+++ (float)(lv_cimag(_in[2])),
+++ (float)(lv_creal(_in[2])),
+++ (float)(lv_cimag(_in[1])),
+++ (float)(lv_creal(_in[1])),
+++ (float)(lv_cimag(_in[0])),
+++ (float)(lv_creal(
+++ _in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+++ _mm256_store_ps((float*)_out, a);
+++ _in += 4;
+++ _out += 4;
+++ }
++ _mm256_zeroupper();
++- for (i = 0; i < (num_points % 4); ++i)
++- {
++- *_out++ = lv_cmake((float)lv_creal(*_in), (float)lv_cimag(*_in));
++- _in++;
++- }
+++ for (i = 0; i < (num_points % 4); ++i) {
+++ *_out++ = lv_cmake((float)lv_creal(*_in), (float)lv_cimag(*_in));
+++ _in++;
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++@@ -157,7 +173,9 @@ static inline void volk_16ic_convert_32fc_a_avx(lv_32fc_t* outputVector, const l
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_16ic_convert_32fc_neon(lv_32fc_t* outputVector, const lv_16sc_t* inputVector, unsigned int num_points)
+++static inline void volk_16ic_convert_32fc_neon(lv_32fc_t* outputVector,
+++ const lv_16sc_t* inputVector,
+++ unsigned int num_points)
++ {
++ const unsigned int sse_iters = num_points / 2;
++
++@@ -169,21 +187,19 @@ static inline void volk_16ic_convert_32fc_neon(lv_32fc_t* outputVector, const lv
++ float32x4_t f32x4;
++ unsigned int i, number;
++
++- for(number = 0; number < sse_iters; number++)
++- {
++- a16x4 = vld1_s16((const int16_t*)_in);
++- __VOLK_PREFETCH(_in + 4);
++- a32x4 = vmovl_s16(a16x4);
++- f32x4 = vcvtq_f32_s32(a32x4);
++- vst1q_f32((float32_t*)_out, f32x4);
++- _in += 2;
++- _out += 2;
++- }
++- for (i = 0; i < (num_points % 2); ++i)
++- {
++- *_out++ = lv_cmake((float)lv_creal(*_in), (float)lv_cimag(*_in));
++- _in++;
++- }
+++ for (number = 0; number < sse_iters; number++) {
+++ a16x4 = vld1_s16((const int16_t*)_in);
+++ __VOLK_PREFETCH(_in + 4);
+++ a32x4 = vmovl_s16(a16x4);
+++ f32x4 = vcvtq_f32_s32(a32x4);
+++ vst1q_f32((float32_t*)_out, f32x4);
+++ _in += 2;
+++ _out += 2;
+++ }
+++ for (i = 0; i < (num_points % 2); ++i) {
+++ *_out++ = lv_cmake((float)lv_creal(*_in), (float)lv_cimag(*_in));
+++ _in++;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++@@ -198,7 +214,9 @@ static inline void volk_16ic_convert_32fc_neon(lv_32fc_t* outputVector, const lv
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void volk_16ic_convert_32fc_u_avx2(lv_32fc_t* outputVector, const lv_16sc_t* inputVector, unsigned int num_points)
+++static inline void volk_16ic_convert_32fc_u_avx2(lv_32fc_t* outputVector,
+++ const lv_16sc_t* inputVector,
+++ unsigned int num_points)
++ {
++ const unsigned int avx_iters = num_points / 8;
++ unsigned int number = 0;
++@@ -208,23 +226,21 @@ static inline void volk_16ic_convert_32fc_u_avx2(lv_32fc_t* outputVector, const
++ __m256i outValInt;
++ __m128i cplxValue;
++
++- for(number = 0; number < avx_iters; number++)
++- {
++- cplxValue = _mm_loadu_si128((__m128i*)complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- outValInt = _mm256_cvtepi16_epi32(cplxValue);
++- outVal = _mm256_cvtepi32_ps(outValInt);
++- _mm256_storeu_ps((float*)outputVectorPtr, outVal);
+++ for (number = 0; number < avx_iters; number++) {
+++ cplxValue = _mm_loadu_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ outValInt = _mm256_cvtepi16_epi32(cplxValue);
+++ outVal = _mm256_cvtepi32_ps(outValInt);
+++ _mm256_storeu_ps((float*)outputVectorPtr, outVal);
++
++- outputVectorPtr += 8;
++- }
+++ outputVectorPtr += 8;
+++ }
++
++ number = avx_iters * 8;
++- for(; number < num_points*2; number++)
++- {
++- *outputVectorPtr++ = (float)*complexVectorPtr++;
++- }
+++ for (; number < num_points * 2; number++) {
+++ *outputVectorPtr++ = (float)*complexVectorPtr++;
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 */
++@@ -232,7 +248,9 @@ static inline void volk_16ic_convert_32fc_u_avx2(lv_32fc_t* outputVector, const
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_16ic_convert_32fc_u_sse2(lv_32fc_t* outputVector, const lv_16sc_t* inputVector, unsigned int num_points)
+++static inline void volk_16ic_convert_32fc_u_sse2(lv_32fc_t* outputVector,
+++ const lv_16sc_t* inputVector,
+++ unsigned int num_points)
++ {
++ const unsigned int sse_iters = num_points / 2;
++
++@@ -241,18 +259,21 @@ static inline void volk_16ic_convert_32fc_u_sse2(lv_32fc_t* outputVector, const
++ __m128 a;
++ unsigned int number;
++
++- for(number = 0; number < sse_iters; number++)
++- {
++- a = _mm_set_ps((float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
++- _mm_storeu_ps((float*)_out, a);
++- _in += 2;
++- _out += 2;
++- }
++- if (num_points & 1)
++- {
++- *_out++ = lv_cmake((float)lv_creal(*_in), (float)lv_cimag(*_in));
++- _in++;
++- }
+++ for (number = 0; number < sse_iters; number++) {
+++ a = _mm_set_ps(
+++ (float)(lv_cimag(_in[1])),
+++ (float)(lv_creal(_in[1])),
+++ (float)(lv_cimag(_in[0])),
+++ (float)(lv_creal(
+++ _in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+++ _mm_storeu_ps((float*)_out, a);
+++ _in += 2;
+++ _out += 2;
+++ }
+++ if (num_points & 1) {
+++ *_out++ = lv_cmake((float)lv_creal(*_in), (float)lv_cimag(*_in));
+++ _in++;
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE2 */
++@@ -261,7 +282,9 @@ static inline void volk_16ic_convert_32fc_u_sse2(lv_32fc_t* outputVector, const
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_16ic_convert_32fc_u_avx(lv_32fc_t* outputVector, const lv_16sc_t* inputVector, unsigned int num_points)
+++static inline void volk_16ic_convert_32fc_u_avx(lv_32fc_t* outputVector,
+++ const lv_16sc_t* inputVector,
+++ unsigned int num_points)
++ {
++ const unsigned int sse_iters = num_points / 4;
++
++@@ -270,21 +293,27 @@ static inline void volk_16ic_convert_32fc_u_avx(lv_32fc_t* outputVector, const l
++ __m256 a;
++ unsigned int i, number;
++
++- for(number = 0; number < sse_iters; number++)
++- {
++- a = _mm256_set_ps((float)(lv_cimag(_in[3])), (float)(lv_creal(_in[3])), (float)(lv_cimag(_in[2])), (float)(lv_creal(_in[2])), (float)(lv_cimag(_in[1])), (float)(lv_creal(_in[1])), (float)(lv_cimag(_in[0])), (float)(lv_creal(_in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
++- _mm256_storeu_ps((float*)_out, a);
++- _in += 4;
++- _out += 4;
++- }
+++ for (number = 0; number < sse_iters; number++) {
+++ a = _mm256_set_ps(
+++ (float)(lv_cimag(_in[3])),
+++ (float)(lv_creal(_in[3])),
+++ (float)(lv_cimag(_in[2])),
+++ (float)(lv_creal(_in[2])),
+++ (float)(lv_cimag(_in[1])),
+++ (float)(lv_creal(_in[1])),
+++ (float)(lv_cimag(_in[0])),
+++ (float)(lv_creal(
+++ _in[0]))); // //load (2 byte imag, 2 byte real) x 2 into 128 bits reg
+++ _mm256_storeu_ps((float*)_out, a);
+++ _in += 4;
+++ _out += 4;
+++ }
++ _mm256_zeroupper();
++- for (i = 0; i < (num_points % 4); ++i)
++- {
++- *_out++ = lv_cmake((float)lv_creal(*_in), (float)lv_cimag(*_in));
++- _in++;
++- }
+++ for (i = 0; i < (num_points % 4); ++i) {
+++ *_out++ = lv_cmake((float)lv_creal(*_in), (float)lv_cimag(*_in));
+++ _in++;
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++ #endif /* INCLUDED_volk_32fc_convert_16ic_u_H */
++-
++diff --git a/kernels/volk/volk_16ic_deinterleave_16i_x2.h b/kernels/volk/volk_16ic_deinterleave_16i_x2.h
++index 40d10b4..9e784a6 100644
++--- a/kernels/volk/volk_16ic_deinterleave_16i_x2.h
+++++ b/kernels/volk/volk_16ic_deinterleave_16i_x2.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16ic_deinterleave_16i_x2(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
++- * \endcode
+++ * void volk_16ic_deinterleave_16i_x2(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t*
+++ * complexVector, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -59,179 +59,241 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16ic_deinterleave_16i_x2_a_avx2(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_16i_x2_a_avx2(int16_t* iBuffer,
+++ int16_t* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- int16_t* qBufferPtr = qBuffer;
++-
++- __m256i MoveMask = _mm256_set_epi8(15,14,11,10,7,6,3,2,13,12,9,8,5,4,1,0, 15,14,11,10,7,6,3,2,13,12,9,8,5,4,1,0);
++-
++- __m256i iMove2, iMove1;
++- __m256i complexVal1, complexVal2, iOutputVal, qOutputVal;
++-
++- unsigned int sixteenthPoints = num_points / 16;
++-
++- for(number = 0; number < sixteenthPoints; number++){
++- complexVal1 = _mm256_load_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++- complexVal2 = _mm256_load_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++-
++- iMove2 = _mm256_shuffle_epi8(complexVal2, MoveMask);
++- iMove1 = _mm256_shuffle_epi8(complexVal1, MoveMask);
++-
++- iOutputVal = _mm256_permute2x128_si256(_mm256_permute4x64_epi64(iMove1,0x08),_mm256_permute4x64_epi64(iMove2,0x80),0x30);
++- qOutputVal = _mm256_permute2x128_si256(_mm256_permute4x64_epi64(iMove1,0x0d),_mm256_permute4x64_epi64(iMove2,0xd0),0x30);
++-
++- _mm256_store_si256((__m256i*)iBufferPtr, iOutputVal);
++- _mm256_store_si256((__m256i*)qBufferPtr, qOutputVal);
++-
++- iBufferPtr += 16;
++- qBufferPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- int16_t* int16ComplexVectorPtr = (int16_t*)complexVectorPtr;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *int16ComplexVectorPtr++;
++- *qBufferPtr++ = *int16ComplexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ int16_t* qBufferPtr = qBuffer;
+++
+++ __m256i MoveMask = _mm256_set_epi8(15,
+++ 14,
+++ 11,
+++ 10,
+++ 7,
+++ 6,
+++ 3,
+++ 2,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 15,
+++ 14,
+++ 11,
+++ 10,
+++ 7,
+++ 6,
+++ 3,
+++ 2,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0);
+++
+++ __m256i iMove2, iMove1;
+++ __m256i complexVal1, complexVal2, iOutputVal, qOutputVal;
+++
+++ unsigned int sixteenthPoints = num_points / 16;
+++
+++ for (number = 0; number < sixteenthPoints; number++) {
+++ complexVal1 = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal2 = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ iMove2 = _mm256_shuffle_epi8(complexVal2, MoveMask);
+++ iMove1 = _mm256_shuffle_epi8(complexVal1, MoveMask);
+++
+++ iOutputVal = _mm256_permute2x128_si256(_mm256_permute4x64_epi64(iMove1, 0x08),
+++ _mm256_permute4x64_epi64(iMove2, 0x80),
+++ 0x30);
+++ qOutputVal = _mm256_permute2x128_si256(_mm256_permute4x64_epi64(iMove1, 0x0d),
+++ _mm256_permute4x64_epi64(iMove2, 0xd0),
+++ 0x30);
+++
+++ _mm256_store_si256((__m256i*)iBufferPtr, iOutputVal);
+++ _mm256_store_si256((__m256i*)qBufferPtr, qOutputVal);
+++
+++ iBufferPtr += 16;
+++ qBufferPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ int16_t* int16ComplexVectorPtr = (int16_t*)complexVectorPtr;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *int16ComplexVectorPtr++;
+++ *qBufferPtr++ = *int16ComplexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_SSSE3
++ #include <tmmintrin.h>
++
++-static inline void
++-volk_16ic_deinterleave_16i_x2_a_ssse3(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_16i_x2_a_ssse3(int16_t* iBuffer,
+++ int16_t* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- int16_t* qBufferPtr = qBuffer;
++-
++- __m128i iMoveMask1 = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
++- __m128i iMoveMask2 = _mm_set_epi8(13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
++-
++- __m128i qMoveMask1 = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 15, 14, 11, 10, 7, 6, 3, 2);
++- __m128i qMoveMask2 = _mm_set_epi8(15, 14, 11, 10, 7, 6, 3, 2, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
++-
++- __m128i complexVal1, complexVal2, iOutputVal, qOutputVal;
++-
++- unsigned int eighthPoints = num_points / 8;
++-
++- for(number = 0; number < eighthPoints; number++){
++- complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 16;
++- complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 16;
++-
++- iOutputVal = _mm_or_si128( _mm_shuffle_epi8(complexVal1, iMoveMask1) , _mm_shuffle_epi8(complexVal2, iMoveMask2));
++- qOutputVal = _mm_or_si128( _mm_shuffle_epi8(complexVal1, qMoveMask1) , _mm_shuffle_epi8(complexVal2, qMoveMask2));
++-
++- _mm_store_si128((__m128i*)iBufferPtr, iOutputVal);
++- _mm_store_si128((__m128i*)qBufferPtr, qOutputVal);
++-
++- iBufferPtr += 8;
++- qBufferPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- int16_t* int16ComplexVectorPtr = (int16_t*)complexVectorPtr;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *int16ComplexVectorPtr++;
++- *qBufferPtr++ = *int16ComplexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ int16_t* qBufferPtr = qBuffer;
+++
+++ __m128i iMoveMask1 = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
+++ __m128i iMoveMask2 = _mm_set_epi8(
+++ 13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+++
+++ __m128i qMoveMask1 = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 15, 14, 11, 10, 7, 6, 3, 2);
+++ __m128i qMoveMask2 = _mm_set_epi8(
+++ 15, 14, 11, 10, 7, 6, 3, 2, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+++
+++ __m128i complexVal1, complexVal2, iOutputVal, qOutputVal;
+++
+++ unsigned int eighthPoints = num_points / 8;
+++
+++ for (number = 0; number < eighthPoints; number++) {
+++ complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++ complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++
+++ iOutputVal = _mm_or_si128(_mm_shuffle_epi8(complexVal1, iMoveMask1),
+++ _mm_shuffle_epi8(complexVal2, iMoveMask2));
+++ qOutputVal = _mm_or_si128(_mm_shuffle_epi8(complexVal1, qMoveMask1),
+++ _mm_shuffle_epi8(complexVal2, qMoveMask2));
+++
+++ _mm_store_si128((__m128i*)iBufferPtr, iOutputVal);
+++ _mm_store_si128((__m128i*)qBufferPtr, qOutputVal);
+++
+++ iBufferPtr += 8;
+++ qBufferPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ int16_t* int16ComplexVectorPtr = (int16_t*)complexVectorPtr;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *int16ComplexVectorPtr++;
+++ *qBufferPtr++ = *int16ComplexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSSE3 */
++
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_16ic_deinterleave_16i_x2_a_sse2(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_16i_x2_a_sse2(int16_t* iBuffer,
+++ int16_t* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int16_t* complexVectorPtr = (int16_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- int16_t* qBufferPtr = qBuffer;
++- __m128i complexVal1, complexVal2, iComplexVal1, iComplexVal2, qComplexVal1, qComplexVal2, iOutputVal, qOutputVal;
++- __m128i lowMask = _mm_set_epi32(0x0, 0x0, 0xFFFFFFFF, 0xFFFFFFFF);
++- __m128i highMask = _mm_set_epi32(0xFFFFFFFF, 0xFFFFFFFF, 0x0, 0x0);
+++ unsigned int number = 0;
+++ const int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ int16_t* qBufferPtr = qBuffer;
+++ __m128i complexVal1, complexVal2, iComplexVal1, iComplexVal2, qComplexVal1,
+++ qComplexVal2, iOutputVal, qOutputVal;
+++ __m128i lowMask = _mm_set_epi32(0x0, 0x0, 0xFFFFFFFF, 0xFFFFFFFF);
+++ __m128i highMask = _mm_set_epi32(0xFFFFFFFF, 0xFFFFFFFF, 0x0, 0x0);
++
++- unsigned int eighthPoints = num_points / 8;
+++ unsigned int eighthPoints = num_points / 8;
++
++- for(number = 0; number < eighthPoints; number++){
++- complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 8;
++- complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 8;
+++ for (number = 0; number < eighthPoints; number++) {
+++ complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 8;
+++ complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- iComplexVal1 = _mm_shufflelo_epi16(complexVal1, _MM_SHUFFLE(3,1,2,0));
+++ iComplexVal1 = _mm_shufflelo_epi16(complexVal1, _MM_SHUFFLE(3, 1, 2, 0));
++
++- iComplexVal1 = _mm_shufflehi_epi16(iComplexVal1, _MM_SHUFFLE(3,1,2,0));
+++ iComplexVal1 = _mm_shufflehi_epi16(iComplexVal1, _MM_SHUFFLE(3, 1, 2, 0));
++
++- iComplexVal1 = _mm_shuffle_epi32(iComplexVal1, _MM_SHUFFLE(3,1,2,0));
+++ iComplexVal1 = _mm_shuffle_epi32(iComplexVal1, _MM_SHUFFLE(3, 1, 2, 0));
++
++- iComplexVal2 = _mm_shufflelo_epi16(complexVal2, _MM_SHUFFLE(3,1,2,0));
+++ iComplexVal2 = _mm_shufflelo_epi16(complexVal2, _MM_SHUFFLE(3, 1, 2, 0));
++
++- iComplexVal2 = _mm_shufflehi_epi16(iComplexVal2, _MM_SHUFFLE(3,1,2,0));
+++ iComplexVal2 = _mm_shufflehi_epi16(iComplexVal2, _MM_SHUFFLE(3, 1, 2, 0));
++
++- iComplexVal2 = _mm_shuffle_epi32(iComplexVal2, _MM_SHUFFLE(2,0,3,1));
+++ iComplexVal2 = _mm_shuffle_epi32(iComplexVal2, _MM_SHUFFLE(2, 0, 3, 1));
++
++- iOutputVal = _mm_or_si128(_mm_and_si128(iComplexVal1, lowMask), _mm_and_si128(iComplexVal2, highMask));
+++ iOutputVal = _mm_or_si128(_mm_and_si128(iComplexVal1, lowMask),
+++ _mm_and_si128(iComplexVal2, highMask));
++
++- _mm_store_si128((__m128i*)iBufferPtr, iOutputVal);
+++ _mm_store_si128((__m128i*)iBufferPtr, iOutputVal);
++
++- qComplexVal1 = _mm_shufflelo_epi16(complexVal1, _MM_SHUFFLE(2,0,3,1));
+++ qComplexVal1 = _mm_shufflelo_epi16(complexVal1, _MM_SHUFFLE(2, 0, 3, 1));
++
++- qComplexVal1 = _mm_shufflehi_epi16(qComplexVal1, _MM_SHUFFLE(2,0,3,1));
+++ qComplexVal1 = _mm_shufflehi_epi16(qComplexVal1, _MM_SHUFFLE(2, 0, 3, 1));
++
++- qComplexVal1 = _mm_shuffle_epi32(qComplexVal1, _MM_SHUFFLE(3,1,2,0));
+++ qComplexVal1 = _mm_shuffle_epi32(qComplexVal1, _MM_SHUFFLE(3, 1, 2, 0));
++
++- qComplexVal2 = _mm_shufflelo_epi16(complexVal2, _MM_SHUFFLE(2,0,3,1));
+++ qComplexVal2 = _mm_shufflelo_epi16(complexVal2, _MM_SHUFFLE(2, 0, 3, 1));
++
++- qComplexVal2 = _mm_shufflehi_epi16(qComplexVal2, _MM_SHUFFLE(2,0,3,1));
+++ qComplexVal2 = _mm_shufflehi_epi16(qComplexVal2, _MM_SHUFFLE(2, 0, 3, 1));
++
++- qComplexVal2 = _mm_shuffle_epi32(qComplexVal2, _MM_SHUFFLE(2,0,3,1));
+++ qComplexVal2 = _mm_shuffle_epi32(qComplexVal2, _MM_SHUFFLE(2, 0, 3, 1));
++
++- qOutputVal = _mm_or_si128(_mm_and_si128(qComplexVal1, lowMask), _mm_and_si128(qComplexVal2, highMask));
+++ qOutputVal = _mm_or_si128(_mm_and_si128(qComplexVal1, lowMask),
+++ _mm_and_si128(qComplexVal2, highMask));
++
++- _mm_store_si128((__m128i*)qBufferPtr, qOutputVal);
+++ _mm_store_si128((__m128i*)qBufferPtr, qOutputVal);
++
++- iBufferPtr += 8;
++- qBufferPtr += 8;
++- }
+++ iBufferPtr += 8;
+++ qBufferPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_16ic_deinterleave_16i_x2_generic(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_16i_x2_generic(int16_t* iBuffer,
+++ int16_t* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- int16_t* qBufferPtr = qBuffer;
++- unsigned int number;
++- for(number = 0; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ int16_t* qBufferPtr = qBuffer;
+++ unsigned int number;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_ORC
++
++-extern void
++-volk_16ic_deinterleave_16i_x2_a_orc_impl(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points);
++-static inline void
++-volk_16ic_deinterleave_16i_x2_u_orc(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++extern void volk_16ic_deinterleave_16i_x2_a_orc_impl(int16_t* iBuffer,
+++ int16_t* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points);
+++static inline void volk_16ic_deinterleave_16i_x2_u_orc(int16_t* iBuffer,
+++ int16_t* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- volk_16ic_deinterleave_16i_x2_a_orc_impl(iBuffer, qBuffer, complexVector, num_points);
+++ volk_16ic_deinterleave_16i_x2_a_orc_impl(iBuffer, qBuffer, complexVector, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++@@ -246,44 +308,83 @@ volk_16ic_deinterleave_16i_x2_u_orc(int16_t* iBuffer, int16_t* qBuffer, const lv
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16ic_deinterleave_16i_x2_u_avx2(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_16i_x2_u_avx2(int16_t* iBuffer,
+++ int16_t* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- int16_t* qBufferPtr = qBuffer;
++-
++- __m256i MoveMask = _mm256_set_epi8(15,14,11,10,7,6,3,2,13,12,9,8,5,4,1,0, 15,14,11,10,7,6,3,2,13,12,9,8,5,4,1,0);
++-
++- __m256i iMove2, iMove1;
++- __m256i complexVal1, complexVal2, iOutputVal, qOutputVal;
++-
++- unsigned int sixteenthPoints = num_points / 16;
++-
++- for(number = 0; number < sixteenthPoints; number++){
++- complexVal1 = _mm256_loadu_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++- complexVal2 = _mm256_loadu_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++-
++- iMove2 = _mm256_shuffle_epi8(complexVal2, MoveMask);
++- iMove1 = _mm256_shuffle_epi8(complexVal1, MoveMask);
++-
++- iOutputVal = _mm256_permute2x128_si256(_mm256_permute4x64_epi64(iMove1,0x08),_mm256_permute4x64_epi64(iMove2,0x80),0x30);
++- qOutputVal = _mm256_permute2x128_si256(_mm256_permute4x64_epi64(iMove1,0x0d),_mm256_permute4x64_epi64(iMove2,0xd0),0x30);
++-
++- _mm256_storeu_si256((__m256i*)iBufferPtr, iOutputVal);
++- _mm256_storeu_si256((__m256i*)qBufferPtr, qOutputVal);
++-
++- iBufferPtr += 16;
++- qBufferPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- int16_t* int16ComplexVectorPtr = (int16_t*)complexVectorPtr;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *int16ComplexVectorPtr++;
++- *qBufferPtr++ = *int16ComplexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ int16_t* qBufferPtr = qBuffer;
+++
+++ __m256i MoveMask = _mm256_set_epi8(15,
+++ 14,
+++ 11,
+++ 10,
+++ 7,
+++ 6,
+++ 3,
+++ 2,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 15,
+++ 14,
+++ 11,
+++ 10,
+++ 7,
+++ 6,
+++ 3,
+++ 2,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0);
+++
+++ __m256i iMove2, iMove1;
+++ __m256i complexVal1, complexVal2, iOutputVal, qOutputVal;
+++
+++ unsigned int sixteenthPoints = num_points / 16;
+++
+++ for (number = 0; number < sixteenthPoints; number++) {
+++ complexVal1 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal2 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ iMove2 = _mm256_shuffle_epi8(complexVal2, MoveMask);
+++ iMove1 = _mm256_shuffle_epi8(complexVal1, MoveMask);
+++
+++ iOutputVal = _mm256_permute2x128_si256(_mm256_permute4x64_epi64(iMove1, 0x08),
+++ _mm256_permute4x64_epi64(iMove2, 0x80),
+++ 0x30);
+++ qOutputVal = _mm256_permute2x128_si256(_mm256_permute4x64_epi64(iMove1, 0x0d),
+++ _mm256_permute4x64_epi64(iMove2, 0xd0),
+++ 0x30);
+++
+++ _mm256_storeu_si256((__m256i*)iBufferPtr, iOutputVal);
+++ _mm256_storeu_si256((__m256i*)qBufferPtr, qOutputVal);
+++
+++ iBufferPtr += 16;
+++ qBufferPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ int16_t* int16ComplexVectorPtr = (int16_t*)complexVectorPtr;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *int16ComplexVectorPtr++;
+++ *qBufferPtr++ = *int16ComplexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_16ic_deinterleave_real_16i.h b/kernels/volk/volk_16ic_deinterleave_real_16i.h
++index c1de553..45fcd99 100644
++--- a/kernels/volk/volk_16ic_deinterleave_real_16i.h
+++++ b/kernels/volk/volk_16ic_deinterleave_real_16i.h
++@@ -25,12 +25,13 @@
++ *
++ * \b Overview
++ *
++- * Deinterleaves the complex 16 bit vector and returns the real (inphase) part of the signal.
+++ * Deinterleaves the complex 16 bit vector and returns the real (inphase) part of the
+++ * signal.
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16ic_deinterleave_real_16i(int16_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
++- * \endcode
+++ * void volk_16ic_deinterleave_real_16i(int16_t* iBuffer, const lv_16sc_t* complexVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -60,79 +61,149 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16ic_deinterleave_real_16i_a_avx2(int16_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_real_16i_a_avx2(int16_t* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int16_t* complexVectorPtr = (int16_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++-
++- __m256i iMoveMask1 = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
++- __m256i iMoveMask2 = _mm256_set_epi8(13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
++-
++- __m256i complexVal1, complexVal2, iOutputVal;
++-
++- unsigned int sixteenthPoints = num_points / 16;
++-
++- for(number = 0; number < sixteenthPoints; number++){
++- complexVal1 = _mm256_load_si256((__m256i*)complexVectorPtr); complexVectorPtr += 16;
++- complexVal2 = _mm256_load_si256((__m256i*)complexVectorPtr); complexVectorPtr += 16;
++-
++- complexVal1 = _mm256_shuffle_epi8(complexVal1, iMoveMask1);
++- complexVal2 = _mm256_shuffle_epi8(complexVal2, iMoveMask2);
++-
++- iOutputVal = _mm256_or_si256(complexVal1, complexVal2);
++- iOutputVal = _mm256_permute4x64_epi64(iOutputVal, 0xd8);
++-
++- _mm256_store_si256((__m256i*)iBufferPtr, iOutputVal);
++-
++- iBufferPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++
+++ __m256i iMoveMask1 = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0);
+++ __m256i iMoveMask2 = _mm256_set_epi8(13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80);
+++
+++ __m256i complexVal1, complexVal2, iOutputVal;
+++
+++ unsigned int sixteenthPoints = num_points / 16;
+++
+++ for (number = 0; number < sixteenthPoints; number++) {
+++ complexVal1 = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++ complexVal2 = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++
+++ complexVal1 = _mm256_shuffle_epi8(complexVal1, iMoveMask1);
+++ complexVal2 = _mm256_shuffle_epi8(complexVal2, iMoveMask2);
+++
+++ iOutputVal = _mm256_or_si256(complexVal1, complexVal2);
+++ iOutputVal = _mm256_permute4x64_epi64(iOutputVal, 0xd8);
+++
+++ _mm256_store_si256((__m256i*)iBufferPtr, iOutputVal);
+++
+++ iBufferPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_SSSE3
++ #include <tmmintrin.h>
++
++-static inline void
++-volk_16ic_deinterleave_real_16i_a_ssse3(int16_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_real_16i_a_ssse3(int16_t* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int16_t* complexVectorPtr = (int16_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
+++ unsigned int number = 0;
+++ const int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
++
++- __m128i iMoveMask1 = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
++- __m128i iMoveMask2 = _mm_set_epi8(13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+++ __m128i iMoveMask1 = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
+++ __m128i iMoveMask2 = _mm_set_epi8(
+++ 13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
++
++- __m128i complexVal1, complexVal2, iOutputVal;
+++ __m128i complexVal1, complexVal2, iOutputVal;
++
++- unsigned int eighthPoints = num_points / 8;
+++ unsigned int eighthPoints = num_points / 8;
++
++- for(number = 0; number < eighthPoints; number++){
++- complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 8;
++- complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 8;
+++ for (number = 0; number < eighthPoints; number++) {
+++ complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 8;
+++ complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- complexVal1 = _mm_shuffle_epi8(complexVal1, iMoveMask1);
++- complexVal2 = _mm_shuffle_epi8(complexVal2, iMoveMask2);
+++ complexVal1 = _mm_shuffle_epi8(complexVal1, iMoveMask1);
+++ complexVal2 = _mm_shuffle_epi8(complexVal2, iMoveMask2);
++
++- iOutputVal = _mm_or_si128(complexVal1, complexVal2);
+++ iOutputVal = _mm_or_si128(complexVal1, complexVal2);
++
++- _mm_store_si128((__m128i*)iBufferPtr, iOutputVal);
+++ _mm_store_si128((__m128i*)iBufferPtr, iOutputVal);
++
++- iBufferPtr += 8;
++- }
+++ iBufferPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSSE3 */
++
++@@ -140,61 +211,66 @@ volk_16ic_deinterleave_real_16i_a_ssse3(int16_t* iBuffer, const lv_16sc_t* compl
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_16ic_deinterleave_real_16i_a_sse2(int16_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_real_16i_a_sse2(int16_t* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int16_t* complexVectorPtr = (int16_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- __m128i complexVal1, complexVal2, iOutputVal;
++- __m128i lowMask = _mm_set_epi32(0x0, 0x0, 0xFFFFFFFF, 0xFFFFFFFF);
++- __m128i highMask = _mm_set_epi32(0xFFFFFFFF, 0xFFFFFFFF, 0x0, 0x0);
+++ unsigned int number = 0;
+++ const int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ __m128i complexVal1, complexVal2, iOutputVal;
+++ __m128i lowMask = _mm_set_epi32(0x0, 0x0, 0xFFFFFFFF, 0xFFFFFFFF);
+++ __m128i highMask = _mm_set_epi32(0xFFFFFFFF, 0xFFFFFFFF, 0x0, 0x0);
++
++- unsigned int eighthPoints = num_points / 8;
+++ unsigned int eighthPoints = num_points / 8;
++
++- for(number = 0; number < eighthPoints; number++){
++- complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 8;
++- complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 8;
+++ for (number = 0; number < eighthPoints; number++) {
+++ complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 8;
+++ complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- complexVal1 = _mm_shufflelo_epi16(complexVal1, _MM_SHUFFLE(3,1,2,0));
+++ complexVal1 = _mm_shufflelo_epi16(complexVal1, _MM_SHUFFLE(3, 1, 2, 0));
++
++- complexVal1 = _mm_shufflehi_epi16(complexVal1, _MM_SHUFFLE(3,1,2,0));
+++ complexVal1 = _mm_shufflehi_epi16(complexVal1, _MM_SHUFFLE(3, 1, 2, 0));
++
++- complexVal1 = _mm_shuffle_epi32(complexVal1, _MM_SHUFFLE(3,1,2,0));
+++ complexVal1 = _mm_shuffle_epi32(complexVal1, _MM_SHUFFLE(3, 1, 2, 0));
++
++- complexVal2 = _mm_shufflelo_epi16(complexVal2, _MM_SHUFFLE(3,1,2,0));
+++ complexVal2 = _mm_shufflelo_epi16(complexVal2, _MM_SHUFFLE(3, 1, 2, 0));
++
++- complexVal2 = _mm_shufflehi_epi16(complexVal2, _MM_SHUFFLE(3,1,2,0));
+++ complexVal2 = _mm_shufflehi_epi16(complexVal2, _MM_SHUFFLE(3, 1, 2, 0));
++
++- complexVal2 = _mm_shuffle_epi32(complexVal2, _MM_SHUFFLE(2,0,3,1));
+++ complexVal2 = _mm_shuffle_epi32(complexVal2, _MM_SHUFFLE(2, 0, 3, 1));
++
++- iOutputVal = _mm_or_si128(_mm_and_si128(complexVal1, lowMask), _mm_and_si128(complexVal2, highMask));
+++ iOutputVal = _mm_or_si128(_mm_and_si128(complexVal1, lowMask),
+++ _mm_and_si128(complexVal2, highMask));
++
++- _mm_store_si128((__m128i*)iBufferPtr, iOutputVal);
+++ _mm_store_si128((__m128i*)iBufferPtr, iOutputVal);
++
++- iBufferPtr += 8;
++- }
+++ iBufferPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_16ic_deinterleave_real_16i_generic(int16_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_real_16i_generic(int16_t* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int16_t* complexVectorPtr = (int16_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- for(number = 0; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -212,40 +288,105 @@ volk_16ic_deinterleave_real_16i_generic(int16_t* iBuffer, const lv_16sc_t* compl
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16ic_deinterleave_real_16i_u_avx2(int16_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_real_16i_u_avx2(int16_t* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int16_t* complexVectorPtr = (int16_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++-
++- __m256i iMoveMask1 = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
++- __m256i iMoveMask2 = _mm256_set_epi8(13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
++-
++- __m256i complexVal1, complexVal2, iOutputVal;
++-
++- unsigned int sixteenthPoints = num_points / 16;
++-
++- for(number = 0; number < sixteenthPoints; number++){
++- complexVal1 = _mm256_loadu_si256((__m256i*)complexVectorPtr); complexVectorPtr += 16;
++- complexVal2 = _mm256_loadu_si256((__m256i*)complexVectorPtr); complexVectorPtr += 16;
++-
++- complexVal1 = _mm256_shuffle_epi8(complexVal1, iMoveMask1);
++- complexVal2 = _mm256_shuffle_epi8(complexVal2, iMoveMask2);
++-
++- iOutputVal = _mm256_or_si256(complexVal1, complexVal2);
++- iOutputVal = _mm256_permute4x64_epi64(iOutputVal, 0xd8);
++-
++- _mm256_storeu_si256((__m256i*)iBufferPtr, iOutputVal);
++-
++- iBufferPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++
+++ __m256i iMoveMask1 = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0);
+++ __m256i iMoveMask2 = _mm256_set_epi8(13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80);
+++
+++ __m256i complexVal1, complexVal2, iOutputVal;
+++
+++ unsigned int sixteenthPoints = num_points / 16;
+++
+++ for (number = 0; number < sixteenthPoints; number++) {
+++ complexVal1 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++ complexVal2 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++
+++ complexVal1 = _mm256_shuffle_epi8(complexVal1, iMoveMask1);
+++ complexVal2 = _mm256_shuffle_epi8(complexVal2, iMoveMask2);
+++
+++ iOutputVal = _mm256_or_si256(complexVal1, complexVal2);
+++ iOutputVal = _mm256_permute4x64_epi64(iOutputVal, 0xd8);
+++
+++ _mm256_storeu_si256((__m256i*)iBufferPtr, iOutputVal);
+++
+++ iBufferPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_16ic_deinterleave_real_8i.h b/kernels/volk/volk_16ic_deinterleave_real_8i.h
++index 1022688..3d8e4ea 100644
++--- a/kernels/volk/volk_16ic_deinterleave_real_8i.h
+++++ b/kernels/volk/volk_16ic_deinterleave_real_8i.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16ic_deinterleave_real_8i(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
++- * \endcode
+++ * void volk_16ic_deinterleave_real_8i(int8_t* iBuffer, const lv_16sc_t* complexVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -61,54 +61,121 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16ic_deinterleave_real_8i_a_avx2(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_real_8i_a_avx2(int8_t* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int8_t* iBufferPtr = iBuffer;
++- __m256i iMoveMask1 = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
++- __m256i iMoveMask2 = _mm256_set_epi8(13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
++- __m256i complexVal1, complexVal2, complexVal3, complexVal4, iOutputVal;
++-
++- unsigned int thirtysecondPoints = num_points / 32;
++-
++- for(number = 0; number < thirtysecondPoints; number++){
++- complexVal1 = _mm256_load_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++- complexVal2 = _mm256_load_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++-
++- complexVal3 = _mm256_load_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++- complexVal4 = _mm256_load_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++-
++- complexVal1 = _mm256_shuffle_epi8(complexVal1, iMoveMask1);
++- complexVal2 = _mm256_shuffle_epi8(complexVal2, iMoveMask2);
++-
++- complexVal1 = _mm256_or_si256(complexVal1, complexVal2);
++- complexVal1 = _mm256_permute4x64_epi64(complexVal1, 0xd8);
++-
++- complexVal3 = _mm256_shuffle_epi8(complexVal3, iMoveMask1);
++- complexVal4 = _mm256_shuffle_epi8(complexVal4, iMoveMask2);
++-
++- complexVal3 = _mm256_or_si256(complexVal3, complexVal4);
++- complexVal3 = _mm256_permute4x64_epi64(complexVal3, 0xd8);
++-
++- complexVal1 = _mm256_srai_epi16(complexVal1, 8);
++- complexVal3 = _mm256_srai_epi16(complexVal3, 8);
++-
++- iOutputVal = _mm256_packs_epi16(complexVal1, complexVal3);
++- iOutputVal = _mm256_permute4x64_epi64(iOutputVal, 0xd8);
++-
++- _mm256_store_si256((__m256i*)iBufferPtr, iOutputVal);
++-
++- iBufferPtr += 32;
++- }
++-
++- number = thirtysecondPoints * 32;
++- int16_t* int16ComplexVectorPtr = (int16_t*)complexVectorPtr;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((int8_t)(*int16ComplexVectorPtr++ >> 8));
++- int16ComplexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int8_t* iBufferPtr = iBuffer;
+++ __m256i iMoveMask1 = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0);
+++ __m256i iMoveMask2 = _mm256_set_epi8(13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80);
+++ __m256i complexVal1, complexVal2, complexVal3, complexVal4, iOutputVal;
+++
+++ unsigned int thirtysecondPoints = num_points / 32;
+++
+++ for (number = 0; number < thirtysecondPoints; number++) {
+++ complexVal1 = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal2 = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ complexVal3 = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal4 = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ complexVal1 = _mm256_shuffle_epi8(complexVal1, iMoveMask1);
+++ complexVal2 = _mm256_shuffle_epi8(complexVal2, iMoveMask2);
+++
+++ complexVal1 = _mm256_or_si256(complexVal1, complexVal2);
+++ complexVal1 = _mm256_permute4x64_epi64(complexVal1, 0xd8);
+++
+++ complexVal3 = _mm256_shuffle_epi8(complexVal3, iMoveMask1);
+++ complexVal4 = _mm256_shuffle_epi8(complexVal4, iMoveMask2);
+++
+++ complexVal3 = _mm256_or_si256(complexVal3, complexVal4);
+++ complexVal3 = _mm256_permute4x64_epi64(complexVal3, 0xd8);
+++
+++ complexVal1 = _mm256_srai_epi16(complexVal1, 8);
+++ complexVal3 = _mm256_srai_epi16(complexVal3, 8);
+++
+++ iOutputVal = _mm256_packs_epi16(complexVal1, complexVal3);
+++ iOutputVal = _mm256_permute4x64_epi64(iOutputVal, 0xd8);
+++
+++ _mm256_store_si256((__m256i*)iBufferPtr, iOutputVal);
+++
+++ iBufferPtr += 32;
+++ }
+++
+++ number = thirtysecondPoints * 32;
+++ int16_t* int16ComplexVectorPtr = (int16_t*)complexVectorPtr;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = ((int8_t)(*int16ComplexVectorPtr++ >> 8));
+++ int16ComplexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -116,105 +183,116 @@ volk_16ic_deinterleave_real_8i_a_avx2(int8_t* iBuffer, const lv_16sc_t* complexV
++ #ifdef LV_HAVE_SSSE3
++ #include <tmmintrin.h>
++
++-static inline void
++-volk_16ic_deinterleave_real_8i_a_ssse3(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_real_8i_a_ssse3(int8_t* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int8_t* iBufferPtr = iBuffer;
++- __m128i iMoveMask1 = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
++- __m128i iMoveMask2 = _mm_set_epi8(13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
++- __m128i complexVal1, complexVal2, complexVal3, complexVal4, iOutputVal;
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int8_t* iBufferPtr = iBuffer;
+++ __m128i iMoveMask1 = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
+++ __m128i iMoveMask2 = _mm_set_epi8(
+++ 13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+++ __m128i complexVal1, complexVal2, complexVal3, complexVal4, iOutputVal;
++
++- unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int sixteenthPoints = num_points / 16;
++
++- for(number = 0; number < sixteenthPoints; number++){
++- complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 16;
++- complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 16;
+++ for (number = 0; number < sixteenthPoints; number++) {
+++ complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++ complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 16;
++
++- complexVal3 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 16;
++- complexVal4 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 16;
+++ complexVal3 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++ complexVal4 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 16;
++
++- complexVal1 = _mm_shuffle_epi8(complexVal1, iMoveMask1);
++- complexVal2 = _mm_shuffle_epi8(complexVal2, iMoveMask2);
+++ complexVal1 = _mm_shuffle_epi8(complexVal1, iMoveMask1);
+++ complexVal2 = _mm_shuffle_epi8(complexVal2, iMoveMask2);
++
++- complexVal1 = _mm_or_si128(complexVal1, complexVal2);
+++ complexVal1 = _mm_or_si128(complexVal1, complexVal2);
++
++- complexVal3 = _mm_shuffle_epi8(complexVal3, iMoveMask1);
++- complexVal4 = _mm_shuffle_epi8(complexVal4, iMoveMask2);
+++ complexVal3 = _mm_shuffle_epi8(complexVal3, iMoveMask1);
+++ complexVal4 = _mm_shuffle_epi8(complexVal4, iMoveMask2);
++
++- complexVal3 = _mm_or_si128(complexVal3, complexVal4);
+++ complexVal3 = _mm_or_si128(complexVal3, complexVal4);
++
++
++- complexVal1 = _mm_srai_epi16(complexVal1, 8);
++- complexVal3 = _mm_srai_epi16(complexVal3, 8);
+++ complexVal1 = _mm_srai_epi16(complexVal1, 8);
+++ complexVal3 = _mm_srai_epi16(complexVal3, 8);
++
++- iOutputVal = _mm_packs_epi16(complexVal1, complexVal3);
+++ iOutputVal = _mm_packs_epi16(complexVal1, complexVal3);
++
++- _mm_store_si128((__m128i*)iBufferPtr, iOutputVal);
+++ _mm_store_si128((__m128i*)iBufferPtr, iOutputVal);
++
++- iBufferPtr += 16;
++- }
+++ iBufferPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- int16_t* int16ComplexVectorPtr = (int16_t*)complexVectorPtr;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((int8_t)(*int16ComplexVectorPtr++ >> 8));
++- int16ComplexVectorPtr++;
++- }
+++ number = sixteenthPoints * 16;
+++ int16_t* int16ComplexVectorPtr = (int16_t*)complexVectorPtr;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = ((int8_t)(*int16ComplexVectorPtr++ >> 8));
+++ int16ComplexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSSE3 */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_16ic_deinterleave_real_8i_generic(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_real_8i_generic(int8_t* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- int16_t* complexVectorPtr = (int16_t*)complexVector;
++- int8_t* iBufferPtr = iBuffer;
++- for(number = 0; number < num_points; number++){
++- *iBufferPtr++ = ((int8_t)(*complexVectorPtr++ >> 8));
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ int8_t* iBufferPtr = iBuffer;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = ((int8_t)(*complexVectorPtr++ >> 8));
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_16ic_deinterleave_real_8i_neon(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_real_8i_neon(int8_t* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- int8_t* iBufferPtr = iBuffer;
++- unsigned int eighth_points = num_points / 8;
++- unsigned int number;
++-
++- int16x8x2_t complexInput;
++- int8x8_t realOutput;
++- for(number = 0; number < eighth_points; number++){
++- complexInput = vld2q_s16(complexVectorPtr);
++- realOutput = vshrn_n_s16(complexInput.val[0], 8);
++- vst1_s8(iBufferPtr, realOutput);
++- complexVectorPtr += 16;
++- iBufferPtr += 8;
++- }
++-
++- for(number = eighth_points*8; number < num_points; number++){
++- *iBufferPtr++ = ((int8_t)(*complexVectorPtr++ >> 8));
++- complexVectorPtr++;
++- }
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ int8_t* iBufferPtr = iBuffer;
+++ unsigned int eighth_points = num_points / 8;
+++ unsigned int number;
+++
+++ int16x8x2_t complexInput;
+++ int8x8_t realOutput;
+++ for (number = 0; number < eighth_points; number++) {
+++ complexInput = vld2q_s16(complexVectorPtr);
+++ realOutput = vshrn_n_s16(complexInput.val[0], 8);
+++ vst1_s8(iBufferPtr, realOutput);
+++ complexVectorPtr += 16;
+++ iBufferPtr += 8;
+++ }
+++
+++ for (number = eighth_points * 8; number < num_points; number++) {
+++ *iBufferPtr++ = ((int8_t)(*complexVectorPtr++ >> 8));
+++ complexVectorPtr++;
+++ }
++ }
++ #endif
++
++ #ifdef LV_HAVE_ORC
++
++-extern void
++-volk_16ic_deinterleave_real_8i_a_orc_impl(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points);
+++extern void volk_16ic_deinterleave_real_8i_a_orc_impl(int8_t* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points);
++
++-static inline void
++-volk_16ic_deinterleave_real_8i_u_orc(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_real_8i_u_orc(int8_t* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++ volk_16ic_deinterleave_real_8i_a_orc_impl(iBuffer, complexVector, num_points);
++ }
++@@ -233,54 +311,121 @@ volk_16ic_deinterleave_real_8i_u_orc(int8_t* iBuffer, const lv_16sc_t* complexVe
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16ic_deinterleave_real_8i_u_avx2(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_deinterleave_real_8i_u_avx2(int8_t* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int8_t* iBufferPtr = iBuffer;
++- __m256i iMoveMask1 = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
++- __m256i iMoveMask2 = _mm256_set_epi8(13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
++- __m256i complexVal1, complexVal2, complexVal3, complexVal4, iOutputVal;
++-
++- unsigned int thirtysecondPoints = num_points / 32;
++-
++- for(number = 0; number < thirtysecondPoints; number++){
++- complexVal1 = _mm256_loadu_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++- complexVal2 = _mm256_loadu_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++-
++- complexVal3 = _mm256_loadu_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++- complexVal4 = _mm256_loadu_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++-
++- complexVal1 = _mm256_shuffle_epi8(complexVal1, iMoveMask1);
++- complexVal2 = _mm256_shuffle_epi8(complexVal2, iMoveMask2);
++-
++- complexVal1 = _mm256_or_si256(complexVal1, complexVal2);
++- complexVal1 = _mm256_permute4x64_epi64(complexVal1, 0xd8);
++-
++- complexVal3 = _mm256_shuffle_epi8(complexVal3, iMoveMask1);
++- complexVal4 = _mm256_shuffle_epi8(complexVal4, iMoveMask2);
++-
++- complexVal3 = _mm256_or_si256(complexVal3, complexVal4);
++- complexVal3 = _mm256_permute4x64_epi64(complexVal3, 0xd8);
++-
++- complexVal1 = _mm256_srai_epi16(complexVal1, 8);
++- complexVal3 = _mm256_srai_epi16(complexVal3, 8);
++-
++- iOutputVal = _mm256_packs_epi16(complexVal1, complexVal3);
++- iOutputVal = _mm256_permute4x64_epi64(iOutputVal, 0xd8);
++-
++- _mm256_storeu_si256((__m256i*)iBufferPtr, iOutputVal);
++-
++- iBufferPtr += 32;
++- }
++-
++- number = thirtysecondPoints * 32;
++- int16_t* int16ComplexVectorPtr = (int16_t*)complexVectorPtr;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((int8_t)(*int16ComplexVectorPtr++ >> 8));
++- int16ComplexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int8_t* iBufferPtr = iBuffer;
+++ __m256i iMoveMask1 = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0);
+++ __m256i iMoveMask2 = _mm256_set_epi8(13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80);
+++ __m256i complexVal1, complexVal2, complexVal3, complexVal4, iOutputVal;
+++
+++ unsigned int thirtysecondPoints = num_points / 32;
+++
+++ for (number = 0; number < thirtysecondPoints; number++) {
+++ complexVal1 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal2 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ complexVal3 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal4 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ complexVal1 = _mm256_shuffle_epi8(complexVal1, iMoveMask1);
+++ complexVal2 = _mm256_shuffle_epi8(complexVal2, iMoveMask2);
+++
+++ complexVal1 = _mm256_or_si256(complexVal1, complexVal2);
+++ complexVal1 = _mm256_permute4x64_epi64(complexVal1, 0xd8);
+++
+++ complexVal3 = _mm256_shuffle_epi8(complexVal3, iMoveMask1);
+++ complexVal4 = _mm256_shuffle_epi8(complexVal4, iMoveMask2);
+++
+++ complexVal3 = _mm256_or_si256(complexVal3, complexVal4);
+++ complexVal3 = _mm256_permute4x64_epi64(complexVal3, 0xd8);
+++
+++ complexVal1 = _mm256_srai_epi16(complexVal1, 8);
+++ complexVal3 = _mm256_srai_epi16(complexVal3, 8);
+++
+++ iOutputVal = _mm256_packs_epi16(complexVal1, complexVal3);
+++ iOutputVal = _mm256_permute4x64_epi64(iOutputVal, 0xd8);
+++
+++ _mm256_storeu_si256((__m256i*)iBufferPtr, iOutputVal);
+++
+++ iBufferPtr += 32;
+++ }
+++
+++ number = thirtysecondPoints * 32;
+++ int16_t* int16ComplexVectorPtr = (int16_t*)complexVectorPtr;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = ((int8_t)(*int16ComplexVectorPtr++ >> 8));
+++ int16ComplexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++ #endif /* INCLUDED_volk_16ic_deinterleave_real_8i_u_H */
++diff --git a/kernels/volk/volk_16ic_magnitude_16i.h b/kernels/volk/volk_16ic_magnitude_16i.h
++index bbe72a8..35b40cb 100644
++--- a/kernels/volk/volk_16ic_magnitude_16i.h
+++++ b/kernels/volk/volk_16ic_magnitude_16i.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16ic_magnitude_16i(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points)
++- * \endcode
+++ * void volk_16ic_magnitude_16i(int16_t* magnitudeVector, const lv_16sc_t* complexVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -54,242 +54,255 @@
++ #ifndef INCLUDED_volk_16ic_magnitude_16i_a_H
++ #define INCLUDED_volk_16ic_magnitude_16i_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++-#include <stdio.h>
++-#include <math.h>
++ #include <limits.h>
+++#include <math.h>
+++#include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16ic_magnitude_16i_a_avx2(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_magnitude_16i_a_avx2(int16_t* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- int16_t* magnitudeVectorPtr = magnitudeVector;
++-
++- __m256 vScalar = _mm256_set1_ps(SHRT_MAX);
++- __m256 invScalar = _mm256_set1_ps(1.0f/SHRT_MAX);
++- __m256i int1, int2;
++- __m128i short1, short2;
++- __m256 cplxValue1, cplxValue2, result;
++- __m256i idx = _mm256_set_epi32(0,0,0,0,5,1,4,0);
++-
++- for(;number < eighthPoints; number++){
++-
++- int1 = _mm256_load_si256((__m256i*)complexVectorPtr);
++- complexVectorPtr += 16;
++- short1 = _mm256_extracti128_si256(int1,0);
++- short2 = _mm256_extracti128_si256(int1,1);
++-
++- int1 = _mm256_cvtepi16_epi32(short1);
++- int2 = _mm256_cvtepi16_epi32(short2);
++- cplxValue1 = _mm256_cvtepi32_ps(int1);
++- cplxValue2 = _mm256_cvtepi32_ps(int2);
++-
++- cplxValue1 = _mm256_mul_ps(cplxValue1, invScalar);
++- cplxValue2 = _mm256_mul_ps(cplxValue2, invScalar);
++-
++- cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
++- cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
++-
++- result = _mm256_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
++-
++- result = _mm256_sqrt_ps(result); // Square root the values
++-
++- result = _mm256_mul_ps(result, vScalar); // Scale the results
++-
++- int1 = _mm256_cvtps_epi32(result);
++- int1 = _mm256_packs_epi32(int1, int1);
++- int1 = _mm256_permutevar8x32_epi32(int1, idx); //permute to compensate for shuffling in hadd and packs
++- short1 = _mm256_extracti128_si256(int1, 0);
++- _mm_store_si128((__m128i*)magnitudeVectorPtr,short1);
++- magnitudeVectorPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- magnitudeVectorPtr = &magnitudeVector[number];
++- complexVectorPtr = (const int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- const float val1Real = (float)(*complexVectorPtr++) / SHRT_MAX;
++- const float val1Imag = (float)(*complexVectorPtr++) / SHRT_MAX;
++- const float val1Result = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag)) * SHRT_MAX;
++- *magnitudeVectorPtr++ = (int16_t)rintf(val1Result);
++- }
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ int16_t* magnitudeVectorPtr = magnitudeVector;
+++
+++ __m256 vScalar = _mm256_set1_ps(SHRT_MAX);
+++ __m256 invScalar = _mm256_set1_ps(1.0f / SHRT_MAX);
+++ __m256i int1, int2;
+++ __m128i short1, short2;
+++ __m256 cplxValue1, cplxValue2, result;
+++ __m256i idx = _mm256_set_epi32(0, 0, 0, 0, 5, 1, 4, 0);
+++
+++ for (; number < eighthPoints; number++) {
+++
+++ int1 = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++ short1 = _mm256_extracti128_si256(int1, 0);
+++ short2 = _mm256_extracti128_si256(int1, 1);
+++
+++ int1 = _mm256_cvtepi16_epi32(short1);
+++ int2 = _mm256_cvtepi16_epi32(short2);
+++ cplxValue1 = _mm256_cvtepi32_ps(int1);
+++ cplxValue2 = _mm256_cvtepi32_ps(int2);
+++
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, invScalar);
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, invScalar);
+++
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
+++
+++ result = _mm256_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
+++
+++ result = _mm256_sqrt_ps(result); // Square root the values
+++
+++ result = _mm256_mul_ps(result, vScalar); // Scale the results
+++
+++ int1 = _mm256_cvtps_epi32(result);
+++ int1 = _mm256_packs_epi32(int1, int1);
+++ int1 = _mm256_permutevar8x32_epi32(
+++ int1, idx); // permute to compensate for shuffling in hadd and packs
+++ short1 = _mm256_extracti128_si256(int1, 0);
+++ _mm_store_si128((__m128i*)magnitudeVectorPtr, short1);
+++ magnitudeVectorPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ magnitudeVectorPtr = &magnitudeVector[number];
+++ complexVectorPtr = (const int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ const float val1Real = (float)(*complexVectorPtr++) / SHRT_MAX;
+++ const float val1Imag = (float)(*complexVectorPtr++) / SHRT_MAX;
+++ const float val1Result =
+++ sqrtf((val1Real * val1Real) + (val1Imag * val1Imag)) * SHRT_MAX;
+++ *magnitudeVectorPtr++ = (int16_t)rintf(val1Result);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_SSE3
++ #include <pmmintrin.h>
++
++-static inline void
++-volk_16ic_magnitude_16i_a_sse3(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_magnitude_16i_a_sse3(int16_t* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- int16_t* magnitudeVectorPtr = magnitudeVector;
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ int16_t* magnitudeVectorPtr = magnitudeVector;
++
++- __m128 vScalar = _mm_set_ps1(SHRT_MAX);
++- __m128 invScalar = _mm_set_ps1(1.0f/SHRT_MAX);
+++ __m128 vScalar = _mm_set_ps1(SHRT_MAX);
+++ __m128 invScalar = _mm_set_ps1(1.0f / SHRT_MAX);
++
++- __m128 cplxValue1, cplxValue2, result;
+++ __m128 cplxValue1, cplxValue2, result;
++
++- __VOLK_ATTR_ALIGNED(16) float inputFloatBuffer[8];
++- __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float inputFloatBuffer[8];
+++ __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- inputFloatBuffer[0] = (float)(complexVectorPtr[0]);
++- inputFloatBuffer[1] = (float)(complexVectorPtr[1]);
++- inputFloatBuffer[2] = (float)(complexVectorPtr[2]);
++- inputFloatBuffer[3] = (float)(complexVectorPtr[3]);
+++ inputFloatBuffer[0] = (float)(complexVectorPtr[0]);
+++ inputFloatBuffer[1] = (float)(complexVectorPtr[1]);
+++ inputFloatBuffer[2] = (float)(complexVectorPtr[2]);
+++ inputFloatBuffer[3] = (float)(complexVectorPtr[3]);
++
++- inputFloatBuffer[4] = (float)(complexVectorPtr[4]);
++- inputFloatBuffer[5] = (float)(complexVectorPtr[5]);
++- inputFloatBuffer[6] = (float)(complexVectorPtr[6]);
++- inputFloatBuffer[7] = (float)(complexVectorPtr[7]);
+++ inputFloatBuffer[4] = (float)(complexVectorPtr[4]);
+++ inputFloatBuffer[5] = (float)(complexVectorPtr[5]);
+++ inputFloatBuffer[6] = (float)(complexVectorPtr[6]);
+++ inputFloatBuffer[7] = (float)(complexVectorPtr[7]);
++
++- cplxValue1 = _mm_load_ps(&inputFloatBuffer[0]);
++- cplxValue2 = _mm_load_ps(&inputFloatBuffer[4]);
+++ cplxValue1 = _mm_load_ps(&inputFloatBuffer[0]);
+++ cplxValue2 = _mm_load_ps(&inputFloatBuffer[4]);
++
++- complexVectorPtr += 8;
+++ complexVectorPtr += 8;
++
++- cplxValue1 = _mm_mul_ps(cplxValue1, invScalar);
++- cplxValue2 = _mm_mul_ps(cplxValue2, invScalar);
+++ cplxValue1 = _mm_mul_ps(cplxValue1, invScalar);
+++ cplxValue2 = _mm_mul_ps(cplxValue2, invScalar);
++
++- cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values
++- cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values
+++ cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values
+++ cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values
++
++- result = _mm_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
+++ result = _mm_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
++
++- result = _mm_sqrt_ps(result); // Square root the values
+++ result = _mm_sqrt_ps(result); // Square root the values
++
++- result = _mm_mul_ps(result, vScalar); // Scale the results
+++ result = _mm_mul_ps(result, vScalar); // Scale the results
++
++- _mm_store_ps(outputFloatBuffer, result);
++- *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[0]);
++- *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[1]);
++- *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[2]);
++- *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[3]);
++- }
+++ _mm_store_ps(outputFloatBuffer, result);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[0]);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[1]);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[2]);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[3]);
+++ }
++
++- number = quarterPoints * 4;
++- magnitudeVectorPtr = &magnitudeVector[number];
++- complexVectorPtr = (const int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- const float val1Real = (float)(*complexVectorPtr++) / SHRT_MAX;
++- const float val1Imag = (float)(*complexVectorPtr++) / SHRT_MAX;
++- const float val1Result = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag)) * SHRT_MAX;
++- *magnitudeVectorPtr++ = (int16_t)rintf(val1Result);
++- }
+++ number = quarterPoints * 4;
+++ magnitudeVectorPtr = &magnitudeVector[number];
+++ complexVectorPtr = (const int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ const float val1Real = (float)(*complexVectorPtr++) / SHRT_MAX;
+++ const float val1Imag = (float)(*complexVectorPtr++) / SHRT_MAX;
+++ const float val1Result =
+++ sqrtf((val1Real * val1Real) + (val1Imag * val1Imag)) * SHRT_MAX;
+++ *magnitudeVectorPtr++ = (int16_t)rintf(val1Result);
+++ }
++ }
++ #endif /* LV_HAVE_SSE3 */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_16ic_magnitude_16i_a_sse(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_magnitude_16i_a_sse(int16_t* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- int16_t* magnitudeVectorPtr = magnitudeVector;
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ int16_t* magnitudeVectorPtr = magnitudeVector;
++
++- __m128 vScalar = _mm_set_ps1(SHRT_MAX);
++- __m128 invScalar = _mm_set_ps1(1.0f/SHRT_MAX);
+++ __m128 vScalar = _mm_set_ps1(SHRT_MAX);
+++ __m128 invScalar = _mm_set_ps1(1.0f / SHRT_MAX);
++
++- __m128 cplxValue1, cplxValue2, iValue, qValue, result;
+++ __m128 cplxValue1, cplxValue2, iValue, qValue, result;
++
++- __VOLK_ATTR_ALIGNED(16) float inputFloatBuffer[4];
++- __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float inputFloatBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- inputFloatBuffer[0] = (float)(complexVectorPtr[0]);
++- inputFloatBuffer[1] = (float)(complexVectorPtr[1]);
++- inputFloatBuffer[2] = (float)(complexVectorPtr[2]);
++- inputFloatBuffer[3] = (float)(complexVectorPtr[3]);
+++ inputFloatBuffer[0] = (float)(complexVectorPtr[0]);
+++ inputFloatBuffer[1] = (float)(complexVectorPtr[1]);
+++ inputFloatBuffer[2] = (float)(complexVectorPtr[2]);
+++ inputFloatBuffer[3] = (float)(complexVectorPtr[3]);
++
++- cplxValue1 = _mm_load_ps(inputFloatBuffer);
++- complexVectorPtr += 4;
+++ cplxValue1 = _mm_load_ps(inputFloatBuffer);
+++ complexVectorPtr += 4;
++
++- inputFloatBuffer[0] = (float)(complexVectorPtr[0]);
++- inputFloatBuffer[1] = (float)(complexVectorPtr[1]);
++- inputFloatBuffer[2] = (float)(complexVectorPtr[2]);
++- inputFloatBuffer[3] = (float)(complexVectorPtr[3]);
+++ inputFloatBuffer[0] = (float)(complexVectorPtr[0]);
+++ inputFloatBuffer[1] = (float)(complexVectorPtr[1]);
+++ inputFloatBuffer[2] = (float)(complexVectorPtr[2]);
+++ inputFloatBuffer[3] = (float)(complexVectorPtr[3]);
++
++- cplxValue2 = _mm_load_ps(inputFloatBuffer);
++- complexVectorPtr += 4;
+++ cplxValue2 = _mm_load_ps(inputFloatBuffer);
+++ complexVectorPtr += 4;
++
++- cplxValue1 = _mm_mul_ps(cplxValue1, invScalar);
++- cplxValue2 = _mm_mul_ps(cplxValue2, invScalar);
+++ cplxValue1 = _mm_mul_ps(cplxValue1, invScalar);
+++ cplxValue2 = _mm_mul_ps(cplxValue2, invScalar);
++
++- // Arrange in i1i2i3i4 format
++- iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
++- // Arrange in q1q2q3q4 format
++- qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
+++ // Arrange in q1q2q3q4 format
+++ qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3, 1, 3, 1));
++
++- iValue = _mm_mul_ps(iValue, iValue); // Square the I values
++- qValue = _mm_mul_ps(qValue, qValue); // Square the Q Values
+++ iValue = _mm_mul_ps(iValue, iValue); // Square the I values
+++ qValue = _mm_mul_ps(qValue, qValue); // Square the Q Values
++
++- result = _mm_add_ps(iValue, qValue); // Add the I2 and Q2 values
+++ result = _mm_add_ps(iValue, qValue); // Add the I2 and Q2 values
++
++- result = _mm_sqrt_ps(result); // Square root the values
+++ result = _mm_sqrt_ps(result); // Square root the values
++
++- result = _mm_mul_ps(result, vScalar); // Scale the results
+++ result = _mm_mul_ps(result, vScalar); // Scale the results
++
++- _mm_store_ps(outputFloatBuffer, result);
++- *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[0]);
++- *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[1]);
++- *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[2]);
++- *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[3]);
++- }
+++ _mm_store_ps(outputFloatBuffer, result);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[0]);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[1]);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[2]);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(outputFloatBuffer[3]);
+++ }
++
++- number = quarterPoints * 4;
++- magnitudeVectorPtr = &magnitudeVector[number];
++- complexVectorPtr = (const int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- const float val1Real = (float)(*complexVectorPtr++) / SHRT_MAX;
++- const float val1Imag = (float)(*complexVectorPtr++) / SHRT_MAX;
++- const float val1Result = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag)) * SHRT_MAX;
++- *magnitudeVectorPtr++ = (int16_t)rintf(val1Result);
++- }
+++ number = quarterPoints * 4;
+++ magnitudeVectorPtr = &magnitudeVector[number];
+++ complexVectorPtr = (const int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ const float val1Real = (float)(*complexVectorPtr++) / SHRT_MAX;
+++ const float val1Imag = (float)(*complexVectorPtr++) / SHRT_MAX;
+++ const float val1Result =
+++ sqrtf((val1Real * val1Real) + (val1Imag * val1Imag)) * SHRT_MAX;
+++ *magnitudeVectorPtr++ = (int16_t)rintf(val1Result);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_16ic_magnitude_16i_generic(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_magnitude_16i_generic(int16_t* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- int16_t* magnitudeVectorPtr = magnitudeVector;
++- unsigned int number = 0;
++- const float scalar = SHRT_MAX;
++- for(number = 0; number < num_points; number++){
++- float real = ((float)(*complexVectorPtr++)) / scalar;
++- float imag = ((float)(*complexVectorPtr++)) / scalar;
++- *magnitudeVectorPtr++ = (int16_t)rintf(sqrtf((real*real) + (imag*imag)) * scalar);
++- }
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ int16_t* magnitudeVectorPtr = magnitudeVector;
+++ unsigned int number = 0;
+++ const float scalar = SHRT_MAX;
+++ for (number = 0; number < num_points; number++) {
+++ float real = ((float)(*complexVectorPtr++)) / scalar;
+++ float imag = ((float)(*complexVectorPtr++)) / scalar;
+++ *magnitudeVectorPtr++ =
+++ (int16_t)rintf(sqrtf((real * real) + (imag * imag)) * scalar);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_ORC_DISABLED
++-extern void
++-volk_16ic_magnitude_16i_a_orc_impl(int16_t* magnitudeVector, const lv_16sc_t* complexVector, float scalar, unsigned int num_points);
++-
++-static inline void
++-volk_16ic_magnitude_16i_u_orc(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points)
+++extern void volk_16ic_magnitude_16i_a_orc_impl(int16_t* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ float scalar,
+++ unsigned int num_points);
+++
+++static inline void volk_16ic_magnitude_16i_u_orc(int16_t* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- volk_16ic_magnitude_16i_a_orc_impl(magnitudeVector, complexVector, SHRT_MAX, num_points);
+++ volk_16ic_magnitude_16i_a_orc_impl(
+++ magnitudeVector, complexVector, SHRT_MAX, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++@@ -300,71 +313,74 @@ volk_16ic_magnitude_16i_u_orc(int16_t* magnitudeVector, const lv_16sc_t* complex
++ #ifndef INCLUDED_volk_16ic_magnitude_16i_u_H
++ #define INCLUDED_volk_16ic_magnitude_16i_u_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16ic_magnitude_16i_u_avx2(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_magnitude_16i_u_avx2(int16_t* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- int16_t* magnitudeVectorPtr = magnitudeVector;
++-
++- __m256 vScalar = _mm256_set1_ps(SHRT_MAX);
++- __m256 invScalar = _mm256_set1_ps(1.0f/SHRT_MAX);
++- __m256i int1, int2;
++- __m128i short1, short2;
++- __m256 cplxValue1, cplxValue2, result;
++- __m256i idx = _mm256_set_epi32(0,0,0,0,5,1,4,0);
++-
++- for(;number < eighthPoints; number++){
++-
++- int1 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
++- complexVectorPtr += 16;
++- short1 = _mm256_extracti128_si256(int1,0);
++- short2 = _mm256_extracti128_si256(int1,1);
++-
++- int1 = _mm256_cvtepi16_epi32(short1);
++- int2 = _mm256_cvtepi16_epi32(short2);
++- cplxValue1 = _mm256_cvtepi32_ps(int1);
++- cplxValue2 = _mm256_cvtepi32_ps(int2);
++-
++- cplxValue1 = _mm256_mul_ps(cplxValue1, invScalar);
++- cplxValue2 = _mm256_mul_ps(cplxValue2, invScalar);
++-
++- cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
++- cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
++-
++- result = _mm256_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
++-
++- result = _mm256_sqrt_ps(result); // Square root the values
++-
++- result = _mm256_mul_ps(result, vScalar); // Scale the results
++-
++- int1 = _mm256_cvtps_epi32(result);
++- int1 = _mm256_packs_epi32(int1, int1);
++- int1 = _mm256_permutevar8x32_epi32(int1, idx); //permute to compensate for shuffling in hadd and packs
++- short1 = _mm256_extracti128_si256(int1, 0);
++- _mm_storeu_si128((__m128i*)magnitudeVectorPtr,short1);
++- magnitudeVectorPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- magnitudeVectorPtr = &magnitudeVector[number];
++- complexVectorPtr = (const int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- const float val1Real = (float)(*complexVectorPtr++) / SHRT_MAX;
++- const float val1Imag = (float)(*complexVectorPtr++) / SHRT_MAX;
++- const float val1Result = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag)) * SHRT_MAX;
++- *magnitudeVectorPtr++ = (int16_t)rintf(val1Result);
++- }
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ int16_t* magnitudeVectorPtr = magnitudeVector;
+++
+++ __m256 vScalar = _mm256_set1_ps(SHRT_MAX);
+++ __m256 invScalar = _mm256_set1_ps(1.0f / SHRT_MAX);
+++ __m256i int1, int2;
+++ __m128i short1, short2;
+++ __m256 cplxValue1, cplxValue2, result;
+++ __m256i idx = _mm256_set_epi32(0, 0, 0, 0, 5, 1, 4, 0);
+++
+++ for (; number < eighthPoints; number++) {
+++
+++ int1 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++ short1 = _mm256_extracti128_si256(int1, 0);
+++ short2 = _mm256_extracti128_si256(int1, 1);
+++
+++ int1 = _mm256_cvtepi16_epi32(short1);
+++ int2 = _mm256_cvtepi16_epi32(short2);
+++ cplxValue1 = _mm256_cvtepi32_ps(int1);
+++ cplxValue2 = _mm256_cvtepi32_ps(int2);
+++
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, invScalar);
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, invScalar);
+++
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
+++
+++ result = _mm256_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
+++
+++ result = _mm256_sqrt_ps(result); // Square root the values
+++
+++ result = _mm256_mul_ps(result, vScalar); // Scale the results
+++
+++ int1 = _mm256_cvtps_epi32(result);
+++ int1 = _mm256_packs_epi32(int1, int1);
+++ int1 = _mm256_permutevar8x32_epi32(
+++ int1, idx); // permute to compensate for shuffling in hadd and packs
+++ short1 = _mm256_extracti128_si256(int1, 0);
+++ _mm_storeu_si128((__m128i*)magnitudeVectorPtr, short1);
+++ magnitudeVectorPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ magnitudeVectorPtr = &magnitudeVector[number];
+++ complexVectorPtr = (const int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ const float val1Real = (float)(*complexVectorPtr++) / SHRT_MAX;
+++ const float val1Imag = (float)(*complexVectorPtr++) / SHRT_MAX;
+++ const float val1Result =
+++ sqrtf((val1Real * val1Real) + (val1Imag * val1Imag)) * SHRT_MAX;
+++ *magnitudeVectorPtr++ = (int16_t)rintf(val1Result);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -372,24 +388,25 @@ volk_16ic_magnitude_16i_u_avx2(int16_t* magnitudeVector, const lv_16sc_t* comple
++ #include <arm_neon.h>
++ #include <volk/volk_neon_intrinsics.h>
++
++-static inline void
++-volk_16ic_magnitude_16i_neonv7(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points)
+++static inline void volk_16ic_magnitude_16i_neonv7(int16_t* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ unsigned int num_points)
++ {
++ unsigned int number = 0;
++ unsigned int quarter_points = num_points / 4;
++-
+++
++ const float scalar = SHRT_MAX;
++ const float inv_scalar = 1.0f / scalar;
++-
+++
++ int16_t* magnitudeVectorPtr = magnitudeVector;
++ const lv_16sc_t* complexVectorPtr = complexVector;
++-
+++
++ float32x4_t mag_vec;
++ float32x4x2_t c_vec;
++-
++- for(number = 0; number < quarter_points; number++) {
+++
+++ for (number = 0; number < quarter_points; number++) {
++ const int16x4x2_t c16_vec = vld2_s16((int16_t*)complexVectorPtr);
++- __VOLK_PREFETCH(complexVectorPtr+4);
+++ __VOLK_PREFETCH(complexVectorPtr + 4);
++ c_vec.val[0] = vcvtq_f32_s32(vmovl_s16(c16_vec.val[0]));
++ c_vec.val[1] = vcvtq_f32_s32(vmovl_s16(c16_vec.val[1]));
++ // Scale to close to 0-1
++@@ -406,15 +423,16 @@ volk_16ic_magnitude_16i_neonv7(int16_t* magnitudeVector, const lv_16sc_t* comple
++ const int16x4_t mag16_vec = vmovn_s32(vcvtq_s32_f32(mag_vec));
++ vst1_s16(magnitudeVectorPtr, mag16_vec);
++ // Advance pointers
++- magnitudeVectorPtr+=4;
++- complexVectorPtr+=4;
+++ magnitudeVectorPtr += 4;
+++ complexVectorPtr += 4;
++ }
++-
+++
++ // Deal with the rest
++- for(number = quarter_points * 4; number < num_points; number++) {
+++ for (number = quarter_points * 4; number < num_points; number++) {
++ const float real = lv_creal(*complexVectorPtr) * inv_scalar;
++ const float imag = lv_cimag(*complexVectorPtr) * inv_scalar;
++- *magnitudeVectorPtr = (int16_t)rintf(sqrtf((real*real) + (imag*imag)) * scalar);
+++ *magnitudeVectorPtr =
+++ (int16_t)rintf(sqrtf((real * real) + (imag * imag)) * scalar);
++ complexVectorPtr++;
++ magnitudeVectorPtr++;
++ }
++diff --git a/kernels/volk/volk_16ic_s32f_deinterleave_32f_x2.h b/kernels/volk/volk_16ic_s32f_deinterleave_32f_x2.h
++index 50d9341..7425ec6 100644
++--- a/kernels/volk/volk_16ic_s32f_deinterleave_32f_x2.h
+++++ b/kernels/volk/volk_16ic_s32f_deinterleave_32f_x2.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16ic_s32f_deinterleave_32f_x2(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
++- * \endcode
+++ * void volk_16ic_s32f_deinterleave_32f_x2(float* iBuffer, float* qBuffer, const
+++ * lv_16sc_t* complexVector, const float scalar, unsigned int num_points){ \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector of 16-bit shorts.
++@@ -56,197 +56,214 @@
++ #ifndef INCLUDED_volk_16ic_s32f_deinterleave_32f_x2_a_H
++ #define INCLUDED_volk_16ic_s32f_deinterleave_32f_x2_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline
++-void volk_16ic_s32f_deinterleave_32f_x2_a_avx2(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void
+++volk_16ic_s32f_deinterleave_32f_x2_a_avx2(float* iBuffer,
+++ float* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
++-
++- uint64_t number = 0;
++- const uint64_t eighthPoints = num_points / 8;
++- __m256 cplxValue1, cplxValue2, iValue, qValue;
++- __m256i cplxValueA, cplxValueB;
++- __m128i cplxValue128;
++-
++- __m256 invScalar = _mm256_set1_ps(1.0/scalar);
++- int16_t* complexVectorPtr = (int16_t*)complexVector;
++- __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
++-
++- for(;number < eighthPoints; number++){
++-
++- cplxValueA = _mm256_load_si256((__m256i*) complexVectorPtr);
++- complexVectorPtr += 16;
++-
++- //cvt
++- cplxValue128 = _mm256_extracti128_si256(cplxValueA, 0);
++- cplxValueB = _mm256_cvtepi16_epi32(cplxValue128);
++- cplxValue1 = _mm256_cvtepi32_ps(cplxValueB);
++- cplxValue128 = _mm256_extracti128_si256(cplxValueA, 1);
++- cplxValueB = _mm256_cvtepi16_epi32(cplxValue128);
++- cplxValue2 = _mm256_cvtepi32_ps(cplxValueB);
++-
++- cplxValue1 = _mm256_mul_ps(cplxValue1, invScalar);
++- cplxValue2 = _mm256_mul_ps(cplxValue2, invScalar);
++-
++- // Arrange in i1i2i3i4 format
++- iValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
++- iValue = _mm256_permutevar8x32_ps(iValue,idx);
++- // Arrange in q1q2q3q4 format
++- qValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));
++- qValue = _mm256_permutevar8x32_ps(qValue,idx);
++-
++- _mm256_store_ps(iBufferPtr, iValue);
++- _mm256_store_ps(qBufferPtr, qValue);
++-
++- iBufferPtr += 8;
++- qBufferPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- complexVectorPtr = (int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
++- *qBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
++- }
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
+++
+++ uint64_t number = 0;
+++ const uint64_t eighthPoints = num_points / 8;
+++ __m256 cplxValue1, cplxValue2, iValue, qValue;
+++ __m256i cplxValueA, cplxValueB;
+++ __m128i cplxValue128;
+++
+++ __m256 invScalar = _mm256_set1_ps(1.0 / scalar);
+++ int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
+++
+++ for (; number < eighthPoints; number++) {
+++
+++ cplxValueA = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++
+++ // cvt
+++ cplxValue128 = _mm256_extracti128_si256(cplxValueA, 0);
+++ cplxValueB = _mm256_cvtepi16_epi32(cplxValue128);
+++ cplxValue1 = _mm256_cvtepi32_ps(cplxValueB);
+++ cplxValue128 = _mm256_extracti128_si256(cplxValueA, 1);
+++ cplxValueB = _mm256_cvtepi16_epi32(cplxValue128);
+++ cplxValue2 = _mm256_cvtepi32_ps(cplxValueB);
+++
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, invScalar);
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, invScalar);
+++
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
+++ iValue = _mm256_permutevar8x32_ps(iValue, idx);
+++ // Arrange in q1q2q3q4 format
+++ qValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3, 1, 3, 1));
+++ qValue = _mm256_permutevar8x32_ps(qValue, idx);
+++
+++ _mm256_store_ps(iBufferPtr, iValue);
+++ _mm256_store_ps(qBufferPtr, qValue);
+++
+++ iBufferPtr += 8;
+++ qBufferPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ complexVectorPtr = (int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
+++ *qBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline
++-void volk_16ic_s32f_deinterleave_32f_x2_a_sse(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void
+++volk_16ic_s32f_deinterleave_32f_x2_a_sse(float* iBuffer,
+++ float* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
++
++- uint64_t number = 0;
++- const uint64_t quarterPoints = num_points / 4;
++- __m128 cplxValue1, cplxValue2, iValue, qValue;
+++ uint64_t number = 0;
+++ const uint64_t quarterPoints = num_points / 4;
+++ __m128 cplxValue1, cplxValue2, iValue, qValue;
++
++- __m128 invScalar = _mm_set_ps1(1.0/scalar);
++- int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ __m128 invScalar = _mm_set_ps1(1.0 / scalar);
+++ int16_t* complexVectorPtr = (int16_t*)complexVector;
++
++- __VOLK_ATTR_ALIGNED(16) float floatBuffer[8];
+++ __VOLK_ATTR_ALIGNED(16) float floatBuffer[8];
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- floatBuffer[0] = (float)(complexVectorPtr[0]);
++- floatBuffer[1] = (float)(complexVectorPtr[1]);
++- floatBuffer[2] = (float)(complexVectorPtr[2]);
++- floatBuffer[3] = (float)(complexVectorPtr[3]);
+++ floatBuffer[0] = (float)(complexVectorPtr[0]);
+++ floatBuffer[1] = (float)(complexVectorPtr[1]);
+++ floatBuffer[2] = (float)(complexVectorPtr[2]);
+++ floatBuffer[3] = (float)(complexVectorPtr[3]);
++
++- floatBuffer[4] = (float)(complexVectorPtr[4]);
++- floatBuffer[5] = (float)(complexVectorPtr[5]);
++- floatBuffer[6] = (float)(complexVectorPtr[6]);
++- floatBuffer[7] = (float)(complexVectorPtr[7]);
+++ floatBuffer[4] = (float)(complexVectorPtr[4]);
+++ floatBuffer[5] = (float)(complexVectorPtr[5]);
+++ floatBuffer[6] = (float)(complexVectorPtr[6]);
+++ floatBuffer[7] = (float)(complexVectorPtr[7]);
++
++- cplxValue1 = _mm_load_ps(&floatBuffer[0]);
++- cplxValue2 = _mm_load_ps(&floatBuffer[4]);
+++ cplxValue1 = _mm_load_ps(&floatBuffer[0]);
+++ cplxValue2 = _mm_load_ps(&floatBuffer[4]);
++
++- complexVectorPtr += 8;
+++ complexVectorPtr += 8;
++
++- cplxValue1 = _mm_mul_ps(cplxValue1, invScalar);
++- cplxValue2 = _mm_mul_ps(cplxValue2, invScalar);
+++ cplxValue1 = _mm_mul_ps(cplxValue1, invScalar);
+++ cplxValue2 = _mm_mul_ps(cplxValue2, invScalar);
++
++- // Arrange in i1i2i3i4 format
++- iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
++- // Arrange in q1q2q3q4 format
++- qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
+++ // Arrange in q1q2q3q4 format
+++ qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3, 1, 3, 1));
++
++- _mm_store_ps(iBufferPtr, iValue);
++- _mm_store_ps(qBufferPtr, qValue);
+++ _mm_store_ps(iBufferPtr, iValue);
+++ _mm_store_ps(qBufferPtr, qValue);
++
++- iBufferPtr += 4;
++- qBufferPtr += 4;
++- }
+++ iBufferPtr += 4;
+++ qBufferPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- complexVectorPtr = (int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
++- *qBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
++- }
+++ number = quarterPoints * 4;
+++ complexVectorPtr = (int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
+++ *qBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++
++ static inline void
++-volk_16ic_s32f_deinterleave_32f_x2_generic(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_16ic_s32f_deinterleave_32f_x2_generic(float* iBuffer,
+++ float* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
++- unsigned int number;
++- for(number = 0; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
++- *qBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
++- }
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
+++ unsigned int number;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
+++ *qBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++-static inline void
++-volk_16ic_s32f_deinterleave_32f_x2_neon(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16ic_s32f_deinterleave_32f_x2_neon(float* iBuffer,
+++ float* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
++- unsigned int eighth_points = num_points / 4;
++- unsigned int number;
++- float iScalar = 1.f/scalar;
++- float32x4_t invScalar;
++- invScalar = vld1q_dup_f32(&iScalar);
++-
++- int16x4x2_t complexInput_s16;
++- int32x4x2_t complexInput_s32;
++- float32x4x2_t complexFloat;
++-
++- for(number = 0; number < eighth_points; number++){
++- complexInput_s16 = vld2_s16(complexVectorPtr);
++- complexInput_s32.val[0] = vmovl_s16(complexInput_s16.val[0]);
++- complexInput_s32.val[1] = vmovl_s16(complexInput_s16.val[1]);
++- complexFloat.val[0] = vcvtq_f32_s32(complexInput_s32.val[0]);
++- complexFloat.val[1] = vcvtq_f32_s32(complexInput_s32.val[1]);
++- complexFloat.val[0] = vmulq_f32(complexFloat.val[0], invScalar);
++- complexFloat.val[1] = vmulq_f32(complexFloat.val[1], invScalar);
++- vst1q_f32(iBufferPtr, complexFloat.val[0]);
++- vst1q_f32(qBufferPtr, complexFloat.val[1]);
++- complexVectorPtr += 8;
++- iBufferPtr += 4;
++- qBufferPtr += 4;
++- }
++-
++- for(number = eighth_points*4; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
++- *qBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
++- }
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
+++ unsigned int eighth_points = num_points / 4;
+++ unsigned int number;
+++ float iScalar = 1.f / scalar;
+++ float32x4_t invScalar;
+++ invScalar = vld1q_dup_f32(&iScalar);
+++
+++ int16x4x2_t complexInput_s16;
+++ int32x4x2_t complexInput_s32;
+++ float32x4x2_t complexFloat;
+++
+++ for (number = 0; number < eighth_points; number++) {
+++ complexInput_s16 = vld2_s16(complexVectorPtr);
+++ complexInput_s32.val[0] = vmovl_s16(complexInput_s16.val[0]);
+++ complexInput_s32.val[1] = vmovl_s16(complexInput_s16.val[1]);
+++ complexFloat.val[0] = vcvtq_f32_s32(complexInput_s32.val[0]);
+++ complexFloat.val[1] = vcvtq_f32_s32(complexInput_s32.val[1]);
+++ complexFloat.val[0] = vmulq_f32(complexFloat.val[0], invScalar);
+++ complexFloat.val[1] = vmulq_f32(complexFloat.val[1], invScalar);
+++ vst1q_f32(iBufferPtr, complexFloat.val[0]);
+++ vst1q_f32(qBufferPtr, complexFloat.val[1]);
+++ complexVectorPtr += 8;
+++ iBufferPtr += 4;
+++ qBufferPtr += 4;
+++ }
+++
+++ for (number = eighth_points * 4; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
+++ *qBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_ORC
++-extern void
++-volk_16ic_s32f_deinterleave_32f_x2_a_orc_impl(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points);
+++extern void volk_16ic_s32f_deinterleave_32f_x2_a_orc_impl(float* iBuffer,
+++ float* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points);
++
++ static inline void
++-volk_16ic_s32f_deinterleave_32f_x2_u_orc(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_16ic_s32f_deinterleave_32f_x2_u_orc(float* iBuffer,
+++ float* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- volk_16ic_s32f_deinterleave_32f_x2_a_orc_impl(iBuffer, qBuffer, complexVector, scalar, num_points);
+++ volk_16ic_s32f_deinterleave_32f_x2_a_orc_impl(
+++ iBuffer, qBuffer, complexVector, scalar, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++@@ -257,66 +274,69 @@ volk_16ic_s32f_deinterleave_32f_x2_u_orc(float* iBuffer, float* qBuffer, const l
++ #ifndef INCLUDED_volk_16ic_s32f_deinterleave_32f_x2_u_H
++ #define INCLUDED_volk_16ic_s32f_deinterleave_32f_x2_u_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline
++-void volk_16ic_s32f_deinterleave_32f_x2_u_avx2(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void
+++volk_16ic_s32f_deinterleave_32f_x2_u_avx2(float* iBuffer,
+++ float* qBuffer,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
++-
++- uint64_t number = 0;
++- const uint64_t eighthPoints = num_points / 8;
++- __m256 cplxValue1, cplxValue2, iValue, qValue;
++- __m256i cplxValueA, cplxValueB;
++- __m128i cplxValue128;
++-
++- __m256 invScalar = _mm256_set1_ps(1.0/scalar);
++- int16_t* complexVectorPtr = (int16_t*)complexVector;
++- __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
++-
++- for(;number < eighthPoints; number++){
++-
++- cplxValueA = _mm256_loadu_si256((__m256i*) complexVectorPtr);
++- complexVectorPtr += 16;
++-
++- //cvt
++- cplxValue128 = _mm256_extracti128_si256(cplxValueA, 0);
++- cplxValueB = _mm256_cvtepi16_epi32(cplxValue128);
++- cplxValue1 = _mm256_cvtepi32_ps(cplxValueB);
++- cplxValue128 = _mm256_extracti128_si256(cplxValueA, 1);
++- cplxValueB = _mm256_cvtepi16_epi32(cplxValue128);
++- cplxValue2 = _mm256_cvtepi32_ps(cplxValueB);
++-
++- cplxValue1 = _mm256_mul_ps(cplxValue1, invScalar);
++- cplxValue2 = _mm256_mul_ps(cplxValue2, invScalar);
++-
++- // Arrange in i1i2i3i4 format
++- iValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
++- iValue = _mm256_permutevar8x32_ps(iValue,idx);
++- // Arrange in q1q2q3q4 format
++- qValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));
++- qValue = _mm256_permutevar8x32_ps(qValue,idx);
++-
++- _mm256_storeu_ps(iBufferPtr, iValue);
++- _mm256_storeu_ps(qBufferPtr, qValue);
++-
++- iBufferPtr += 8;
++- qBufferPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- complexVectorPtr = (int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
++- *qBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
++- }
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
+++
+++ uint64_t number = 0;
+++ const uint64_t eighthPoints = num_points / 8;
+++ __m256 cplxValue1, cplxValue2, iValue, qValue;
+++ __m256i cplxValueA, cplxValueB;
+++ __m128i cplxValue128;
+++
+++ __m256 invScalar = _mm256_set1_ps(1.0 / scalar);
+++ int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
+++
+++ for (; number < eighthPoints; number++) {
+++
+++ cplxValueA = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++
+++ // cvt
+++ cplxValue128 = _mm256_extracti128_si256(cplxValueA, 0);
+++ cplxValueB = _mm256_cvtepi16_epi32(cplxValue128);
+++ cplxValue1 = _mm256_cvtepi32_ps(cplxValueB);
+++ cplxValue128 = _mm256_extracti128_si256(cplxValueA, 1);
+++ cplxValueB = _mm256_cvtepi16_epi32(cplxValue128);
+++ cplxValue2 = _mm256_cvtepi32_ps(cplxValueB);
+++
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, invScalar);
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, invScalar);
+++
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
+++ iValue = _mm256_permutevar8x32_ps(iValue, idx);
+++ // Arrange in q1q2q3q4 format
+++ qValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3, 1, 3, 1));
+++ qValue = _mm256_permutevar8x32_ps(qValue, idx);
+++
+++ _mm256_storeu_ps(iBufferPtr, iValue);
+++ _mm256_storeu_ps(qBufferPtr, qValue);
+++
+++ iBufferPtr += 8;
+++ qBufferPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ complexVectorPtr = (int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
+++ *qBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_16ic_s32f_deinterleave_real_32f.h b/kernels/volk/volk_16ic_s32f_deinterleave_real_32f.h
++index 713e6a1..8b72d1c 100644
++--- a/kernels/volk/volk_16ic_s32f_deinterleave_real_32f.h
+++++ b/kernels/volk/volk_16ic_s32f_deinterleave_real_32f.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16ic_s32f_deinterleave_real_32f(float* iBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
++- * \endcode
+++ * void volk_16ic_s32f_deinterleave_real_32f(float* iBuffer, const lv_16sc_t*
+++ * complexVector, const float scalar, unsigned int num_points){ \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector of 16-bit shorts.
++@@ -56,55 +56,88 @@
++ #ifndef INCLUDED_volk_16ic_s32f_deinterleave_real_32f_a_H
++ #define INCLUDED_volk_16ic_s32f_deinterleave_real_32f_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++ static inline void
++-volk_16ic_s32f_deinterleave_real_32f_a_avx2(float* iBuffer, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_16ic_s32f_deinterleave_real_32f_a_avx2(float* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++-
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- __m256 iFloatValue;
++-
++- const float iScalar= 1.0 / scalar;
++- __m256 invScalar = _mm256_set1_ps(iScalar);
++- __m256i complexVal, iIntVal;
++- __m128i complexVal128;
++- int8_t* complexVectorPtr = (int8_t*)complexVector;
++-
++- __m256i moveMask = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
++-
++- for(;number < eighthPoints; number++){
++- complexVal = _mm256_load_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++- complexVal = _mm256_shuffle_epi8(complexVal, moveMask);
++- complexVal = _mm256_permute4x64_epi64(complexVal, 0xd8);
++- complexVal128 = _mm256_extracti128_si256(complexVal, 0);
++-
++- iIntVal = _mm256_cvtepi16_epi32(complexVal128);
++- iFloatValue = _mm256_cvtepi32_ps(iIntVal);
++-
++- iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
++-
++- _mm256_store_ps(iBufferPtr, iFloatValue);
++-
++- iBufferPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- int16_t* sixteenTComplexVectorPtr = (int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((float)(*sixteenTComplexVectorPtr++)) * iScalar;
++- sixteenTComplexVectorPtr++;
++- }
++-
+++ float* iBufferPtr = iBuffer;
+++
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ __m256 iFloatValue;
+++
+++ const float iScalar = 1.0 / scalar;
+++ __m256 invScalar = _mm256_set1_ps(iScalar);
+++ __m256i complexVal, iIntVal;
+++ __m128i complexVal128;
+++ int8_t* complexVectorPtr = (int8_t*)complexVector;
+++
+++ __m256i moveMask = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0);
+++
+++ for (; number < eighthPoints; number++) {
+++ complexVal = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal = _mm256_shuffle_epi8(complexVal, moveMask);
+++ complexVal = _mm256_permute4x64_epi64(complexVal, 0xd8);
+++ complexVal128 = _mm256_extracti128_si256(complexVal, 0);
+++
+++ iIntVal = _mm256_cvtepi16_epi32(complexVal128);
+++ iFloatValue = _mm256_cvtepi32_ps(iIntVal);
+++
+++ iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
+++
+++ _mm256_store_ps(iBufferPtr, iFloatValue);
+++
+++ iBufferPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ int16_t* sixteenTComplexVectorPtr = (int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = ((float)(*sixteenTComplexVectorPtr++)) * iScalar;
+++ sixteenTComplexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -112,44 +145,47 @@ volk_16ic_s32f_deinterleave_real_32f_a_avx2(float* iBuffer, const lv_16sc_t* com
++ #include <smmintrin.h>
++
++ static inline void
++-volk_16ic_s32f_deinterleave_real_32f_a_sse4_1(float* iBuffer, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_16ic_s32f_deinterleave_real_32f_a_sse4_1(float* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++-
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ float* iBufferPtr = iBuffer;
++
++- __m128 iFloatValue;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float iScalar= 1.0 / scalar;
++- __m128 invScalar = _mm_set_ps1(iScalar);
++- __m128i complexVal, iIntVal;
++- int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ __m128 iFloatValue;
++
++- __m128i moveMask = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
+++ const float iScalar = 1.0 / scalar;
+++ __m128 invScalar = _mm_set_ps1(iScalar);
+++ __m128i complexVal, iIntVal;
+++ int8_t* complexVectorPtr = (int8_t*)complexVector;
++
++- for(;number < quarterPoints; number++){
++- complexVal = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 16;
++- complexVal = _mm_shuffle_epi8(complexVal, moveMask);
+++ __m128i moveMask = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
++
++- iIntVal = _mm_cvtepi16_epi32(complexVal);
++- iFloatValue = _mm_cvtepi32_ps(iIntVal);
+++ for (; number < quarterPoints; number++) {
+++ complexVal = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++ complexVal = _mm_shuffle_epi8(complexVal, moveMask);
++
++- iFloatValue = _mm_mul_ps(iFloatValue, invScalar);
+++ iIntVal = _mm_cvtepi16_epi32(complexVal);
+++ iFloatValue = _mm_cvtepi32_ps(iIntVal);
++
++- _mm_store_ps(iBufferPtr, iFloatValue);
+++ iFloatValue = _mm_mul_ps(iFloatValue, invScalar);
++
++- iBufferPtr += 4;
++- }
+++ _mm_store_ps(iBufferPtr, iFloatValue);
++
++- number = quarterPoints * 4;
++- int16_t* sixteenTComplexVectorPtr = (int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((float)(*sixteenTComplexVectorPtr++)) * iScalar;
++- sixteenTComplexVectorPtr++;
++- }
+++ iBufferPtr += 4;
+++ }
++
+++ number = quarterPoints * 4;
+++ int16_t* sixteenTComplexVectorPtr = (int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = ((float)(*sixteenTComplexVectorPtr++)) * iScalar;
+++ sixteenTComplexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++@@ -157,59 +193,66 @@ volk_16ic_s32f_deinterleave_real_32f_a_sse4_1(float* iBuffer, const lv_16sc_t* c
++ #include <xmmintrin.h>
++
++ static inline void
++-volk_16ic_s32f_deinterleave_real_32f_a_sse(float* iBuffer, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_16ic_s32f_deinterleave_real_32f_a_sse(float* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
+++ float* iBufferPtr = iBuffer;
++
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++- __m128 iValue;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++ __m128 iValue;
++
++- const float iScalar = 1.0/scalar;
++- __m128 invScalar = _mm_set_ps1(iScalar);
++- int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ const float iScalar = 1.0 / scalar;
+++ __m128 invScalar = _mm_set_ps1(iScalar);
+++ int16_t* complexVectorPtr = (int16_t*)complexVector;
++
++- __VOLK_ATTR_ALIGNED(16) float floatBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float floatBuffer[4];
++
++- for(;number < quarterPoints; number++){
++- floatBuffer[0] = (float)(*complexVectorPtr); complexVectorPtr += 2;
++- floatBuffer[1] = (float)(*complexVectorPtr); complexVectorPtr += 2;
++- floatBuffer[2] = (float)(*complexVectorPtr); complexVectorPtr += 2;
++- floatBuffer[3] = (float)(*complexVectorPtr); complexVectorPtr += 2;
+++ for (; number < quarterPoints; number++) {
+++ floatBuffer[0] = (float)(*complexVectorPtr);
+++ complexVectorPtr += 2;
+++ floatBuffer[1] = (float)(*complexVectorPtr);
+++ complexVectorPtr += 2;
+++ floatBuffer[2] = (float)(*complexVectorPtr);
+++ complexVectorPtr += 2;
+++ floatBuffer[3] = (float)(*complexVectorPtr);
+++ complexVectorPtr += 2;
++
++- iValue = _mm_load_ps(floatBuffer);
+++ iValue = _mm_load_ps(floatBuffer);
++
++- iValue = _mm_mul_ps(iValue, invScalar);
+++ iValue = _mm_mul_ps(iValue, invScalar);
++
++- _mm_store_ps(iBufferPtr, iValue);
+++ _mm_store_ps(iBufferPtr, iValue);
++
++- iBufferPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- complexVectorPtr = (int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((float)(*complexVectorPtr++)) * iScalar;
++- complexVectorPtr++;
++- }
+++ iBufferPtr += 4;
+++ }
++
+++ number = quarterPoints * 4;
+++ complexVectorPtr = (int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = ((float)(*complexVectorPtr++)) * iScalar;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++ static inline void
++-volk_16ic_s32f_deinterleave_real_32f_generic(float* iBuffer, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_16ic_s32f_deinterleave_real_32f_generic(float* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- float* iBufferPtr = iBuffer;
++- const float invScalar = 1.0 / scalar;
++- for(number = 0; number < num_points; number++){
++- *iBufferPtr++ = ((float)(*complexVectorPtr++)) * invScalar;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ float* iBufferPtr = iBuffer;
+++ const float invScalar = 1.0 / scalar;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = ((float)(*complexVectorPtr++)) * invScalar;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -219,55 +262,88 @@ volk_16ic_s32f_deinterleave_real_32f_generic(float* iBuffer, const lv_16sc_t* co
++ #ifndef INCLUDED_volk_16ic_s32f_deinterleave_real_32f_u_H
++ #define INCLUDED_volk_16ic_s32f_deinterleave_real_32f_u_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++ static inline void
++-volk_16ic_s32f_deinterleave_real_32f_u_avx2(float* iBuffer, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_16ic_s32f_deinterleave_real_32f_u_avx2(float* iBuffer,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++-
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- __m256 iFloatValue;
++-
++- const float iScalar= 1.0 / scalar;
++- __m256 invScalar = _mm256_set1_ps(iScalar);
++- __m256i complexVal, iIntVal;
++- __m128i complexVal128;
++- int8_t* complexVectorPtr = (int8_t*)complexVector;
++-
++- __m256i moveMask = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 13, 12, 9, 8, 5, 4, 1, 0);
++-
++- for(;number < eighthPoints; number++){
++- complexVal = _mm256_loadu_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++- complexVal = _mm256_shuffle_epi8(complexVal, moveMask);
++- complexVal = _mm256_permute4x64_epi64(complexVal, 0xd8);
++- complexVal128 = _mm256_extracti128_si256(complexVal, 0);
++-
++- iIntVal = _mm256_cvtepi16_epi32(complexVal128);
++- iFloatValue = _mm256_cvtepi32_ps(iIntVal);
++-
++- iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
++-
++- _mm256_storeu_ps(iBufferPtr, iFloatValue);
++-
++- iBufferPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- int16_t* sixteenTComplexVectorPtr = (int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((float)(*sixteenTComplexVectorPtr++)) * iScalar;
++- sixteenTComplexVectorPtr++;
++- }
++-
+++ float* iBufferPtr = iBuffer;
+++
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ __m256 iFloatValue;
+++
+++ const float iScalar = 1.0 / scalar;
+++ __m256 invScalar = _mm256_set1_ps(iScalar);
+++ __m256i complexVal, iIntVal;
+++ __m128i complexVal128;
+++ int8_t* complexVectorPtr = (int8_t*)complexVector;
+++
+++ __m256i moveMask = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 13,
+++ 12,
+++ 9,
+++ 8,
+++ 5,
+++ 4,
+++ 1,
+++ 0);
+++
+++ for (; number < eighthPoints; number++) {
+++ complexVal = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal = _mm256_shuffle_epi8(complexVal, moveMask);
+++ complexVal = _mm256_permute4x64_epi64(complexVal, 0xd8);
+++ complexVal128 = _mm256_extracti128_si256(complexVal, 0);
+++
+++ iIntVal = _mm256_cvtepi16_epi32(complexVal128);
+++ iFloatValue = _mm256_cvtepi32_ps(iIntVal);
+++
+++ iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
+++
+++ _mm256_storeu_ps(iBufferPtr, iFloatValue);
+++
+++ iBufferPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ int16_t* sixteenTComplexVectorPtr = (int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = ((float)(*sixteenTComplexVectorPtr++)) * iScalar;
+++ sixteenTComplexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_16ic_s32f_magnitude_32f.h b/kernels/volk/volk_16ic_s32f_magnitude_32f.h
++index bb0459c..c3e3605 100644
++--- a/kernels/volk/volk_16ic_s32f_magnitude_32f.h
+++++ b/kernels/volk/volk_16ic_s32f_magnitude_32f.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16ic_s32f_magnitude_32f(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points)
++- * \endcode
+++ * void volk_16ic_s32f_magnitude_32f(float* magnitudeVector, const lv_16sc_t*
+++ * complexVector, const float scalar, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector of complex 16-bit shorts.
++@@ -55,67 +55,68 @@
++ #ifndef INCLUDED_volk_16ic_s32f_magnitude_32f_a_H
++ #define INCLUDED_volk_16ic_s32f_magnitude_32f_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16ic_s32f_magnitude_32f_a_avx2(float* magnitudeVector, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16ic_s32f_magnitude_32f_a_avx2(float* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
++
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
+++ __m256 invScalar = _mm256_set1_ps(1.0 / scalar);
++
++- __m256 invScalar = _mm256_set1_ps(1.0/scalar);
+++ __m256 cplxValue1, cplxValue2, result;
+++ __m256i int1, int2;
+++ __m128i short1, short2;
+++ __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
++
++- __m256 cplxValue1, cplxValue2, result;
++- __m256i int1, int2;
++- __m128i short1, short2;
++- __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
+++ for (; number < eighthPoints; number++) {
++
++- for(;number < eighthPoints; number++){
++-
++- int1 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
++- complexVectorPtr += 16;
++- short1 = _mm256_extracti128_si256(int1,0);
++- short2 = _mm256_extracti128_si256(int1,1);
+++ int1 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++ short1 = _mm256_extracti128_si256(int1, 0);
+++ short2 = _mm256_extracti128_si256(int1, 1);
++
++- int1 = _mm256_cvtepi16_epi32(short1);
++- int2 = _mm256_cvtepi16_epi32(short2);
++- cplxValue1 = _mm256_cvtepi32_ps(int1);
++- cplxValue2 = _mm256_cvtepi32_ps(int2);
+++ int1 = _mm256_cvtepi16_epi32(short1);
+++ int2 = _mm256_cvtepi16_epi32(short2);
+++ cplxValue1 = _mm256_cvtepi32_ps(int1);
+++ cplxValue2 = _mm256_cvtepi32_ps(int2);
++
++- cplxValue1 = _mm256_mul_ps(cplxValue1, invScalar);
++- cplxValue2 = _mm256_mul_ps(cplxValue2, invScalar);
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, invScalar);
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, invScalar);
++
++- cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
++- cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
++
++- result = _mm256_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
++- result = _mm256_permutevar8x32_ps(result, idx);
+++ result = _mm256_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
+++ result = _mm256_permutevar8x32_ps(result, idx);
++
++- result = _mm256_sqrt_ps(result); // Square root the values
+++ result = _mm256_sqrt_ps(result); // Square root the values
++
++- _mm256_store_ps(magnitudeVectorPtr, result);
+++ _mm256_store_ps(magnitudeVectorPtr, result);
++
++- magnitudeVectorPtr += 8;
++- }
+++ magnitudeVectorPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- magnitudeVectorPtr = &magnitudeVector[number];
++- complexVectorPtr = (const int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- float val1Real = (float)(*complexVectorPtr++) / scalar;
++- float val1Imag = (float)(*complexVectorPtr++) / scalar;
++- *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
++- }
+++ number = eighthPoints * 8;
+++ magnitudeVectorPtr = &magnitudeVector[number];
+++ complexVectorPtr = (const int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ float val1Real = (float)(*complexVectorPtr++) / scalar;
+++ float val1Imag = (float)(*complexVectorPtr++) / scalar;
+++ *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -123,127 +124,129 @@ volk_16ic_s32f_magnitude_32f_a_avx2(float* magnitudeVector, const lv_16sc_t* com
++ #ifdef LV_HAVE_SSE3
++ #include <pmmintrin.h>
++
++-static inline void
++-volk_16ic_s32f_magnitude_32f_a_sse3(float* magnitudeVector, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16ic_s32f_magnitude_32f_a_sse3(float* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
++
++- __m128 invScalar = _mm_set_ps1(1.0/scalar);
+++ __m128 invScalar = _mm_set_ps1(1.0 / scalar);
++
++- __m128 cplxValue1, cplxValue2, result;
+++ __m128 cplxValue1, cplxValue2, result;
++
++- __VOLK_ATTR_ALIGNED(16) float inputFloatBuffer[8];
+++ __VOLK_ATTR_ALIGNED(16) float inputFloatBuffer[8];
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- inputFloatBuffer[0] = (float)(complexVectorPtr[0]);
++- inputFloatBuffer[1] = (float)(complexVectorPtr[1]);
++- inputFloatBuffer[2] = (float)(complexVectorPtr[2]);
++- inputFloatBuffer[3] = (float)(complexVectorPtr[3]);
+++ inputFloatBuffer[0] = (float)(complexVectorPtr[0]);
+++ inputFloatBuffer[1] = (float)(complexVectorPtr[1]);
+++ inputFloatBuffer[2] = (float)(complexVectorPtr[2]);
+++ inputFloatBuffer[3] = (float)(complexVectorPtr[3]);
++
++- inputFloatBuffer[4] = (float)(complexVectorPtr[4]);
++- inputFloatBuffer[5] = (float)(complexVectorPtr[5]);
++- inputFloatBuffer[6] = (float)(complexVectorPtr[6]);
++- inputFloatBuffer[7] = (float)(complexVectorPtr[7]);
+++ inputFloatBuffer[4] = (float)(complexVectorPtr[4]);
+++ inputFloatBuffer[5] = (float)(complexVectorPtr[5]);
+++ inputFloatBuffer[6] = (float)(complexVectorPtr[6]);
+++ inputFloatBuffer[7] = (float)(complexVectorPtr[7]);
++
++- cplxValue1 = _mm_load_ps(&inputFloatBuffer[0]);
++- cplxValue2 = _mm_load_ps(&inputFloatBuffer[4]);
+++ cplxValue1 = _mm_load_ps(&inputFloatBuffer[0]);
+++ cplxValue2 = _mm_load_ps(&inputFloatBuffer[4]);
++
++- complexVectorPtr += 8;
+++ complexVectorPtr += 8;
++
++- cplxValue1 = _mm_mul_ps(cplxValue1, invScalar);
++- cplxValue2 = _mm_mul_ps(cplxValue2, invScalar);
+++ cplxValue1 = _mm_mul_ps(cplxValue1, invScalar);
+++ cplxValue2 = _mm_mul_ps(cplxValue2, invScalar);
++
++- cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values
++- cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values
+++ cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values
+++ cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values
++
++- result = _mm_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
+++ result = _mm_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
++
++- result = _mm_sqrt_ps(result); // Square root the values
+++ result = _mm_sqrt_ps(result); // Square root the values
++
++- _mm_store_ps(magnitudeVectorPtr, result);
+++ _mm_store_ps(magnitudeVectorPtr, result);
++
++- magnitudeVectorPtr += 4;
++- }
+++ magnitudeVectorPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- magnitudeVectorPtr = &magnitudeVector[number];
++- complexVectorPtr = (const int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- float val1Real = (float)(*complexVectorPtr++) / scalar;
++- float val1Imag = (float)(*complexVectorPtr++) / scalar;
++- *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
++- }
+++ number = quarterPoints * 4;
+++ magnitudeVectorPtr = &magnitudeVector[number];
+++ complexVectorPtr = (const int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ float val1Real = (float)(*complexVectorPtr++) / scalar;
+++ float val1Imag = (float)(*complexVectorPtr++) / scalar;
+++ *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
+++ }
++ }
++ #endif /* LV_HAVE_SSE3 */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_16ic_s32f_magnitude_32f_a_sse(float* magnitudeVector, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16ic_s32f_magnitude_32f_a_sse(float* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
++
++- const float iScalar = 1.0 / scalar;
++- __m128 invScalar = _mm_set_ps1(iScalar);
+++ const float iScalar = 1.0 / scalar;
+++ __m128 invScalar = _mm_set_ps1(iScalar);
++
++- __m128 cplxValue1, cplxValue2, result, re, im;
+++ __m128 cplxValue1, cplxValue2, result, re, im;
++
++- __VOLK_ATTR_ALIGNED(16) float inputFloatBuffer[8];
+++ __VOLK_ATTR_ALIGNED(16) float inputFloatBuffer[8];
++
++- for(;number < quarterPoints; number++){
++- inputFloatBuffer[0] = (float)(complexVectorPtr[0]);
++- inputFloatBuffer[1] = (float)(complexVectorPtr[1]);
++- inputFloatBuffer[2] = (float)(complexVectorPtr[2]);
++- inputFloatBuffer[3] = (float)(complexVectorPtr[3]);
+++ for (; number < quarterPoints; number++) {
+++ inputFloatBuffer[0] = (float)(complexVectorPtr[0]);
+++ inputFloatBuffer[1] = (float)(complexVectorPtr[1]);
+++ inputFloatBuffer[2] = (float)(complexVectorPtr[2]);
+++ inputFloatBuffer[3] = (float)(complexVectorPtr[3]);
++
++- inputFloatBuffer[4] = (float)(complexVectorPtr[4]);
++- inputFloatBuffer[5] = (float)(complexVectorPtr[5]);
++- inputFloatBuffer[6] = (float)(complexVectorPtr[6]);
++- inputFloatBuffer[7] = (float)(complexVectorPtr[7]);
+++ inputFloatBuffer[4] = (float)(complexVectorPtr[4]);
+++ inputFloatBuffer[5] = (float)(complexVectorPtr[5]);
+++ inputFloatBuffer[6] = (float)(complexVectorPtr[6]);
+++ inputFloatBuffer[7] = (float)(complexVectorPtr[7]);
++
++- cplxValue1 = _mm_load_ps(&inputFloatBuffer[0]);
++- cplxValue2 = _mm_load_ps(&inputFloatBuffer[4]);
+++ cplxValue1 = _mm_load_ps(&inputFloatBuffer[0]);
+++ cplxValue2 = _mm_load_ps(&inputFloatBuffer[4]);
++
++- re = _mm_shuffle_ps(cplxValue1, cplxValue2, 0x88);
++- im = _mm_shuffle_ps(cplxValue1, cplxValue2, 0xdd);
+++ re = _mm_shuffle_ps(cplxValue1, cplxValue2, 0x88);
+++ im = _mm_shuffle_ps(cplxValue1, cplxValue2, 0xdd);
++
++- complexVectorPtr += 8;
+++ complexVectorPtr += 8;
++
++- cplxValue1 = _mm_mul_ps(re, invScalar);
++- cplxValue2 = _mm_mul_ps(im, invScalar);
+++ cplxValue1 = _mm_mul_ps(re, invScalar);
+++ cplxValue2 = _mm_mul_ps(im, invScalar);
++
++- cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values
++- cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values
+++ cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values
+++ cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values
++
++- result = _mm_add_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
+++ result = _mm_add_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
++
++- result = _mm_sqrt_ps(result); // Square root the values
+++ result = _mm_sqrt_ps(result); // Square root the values
++
++- _mm_store_ps(magnitudeVectorPtr, result);
+++ _mm_store_ps(magnitudeVectorPtr, result);
++
++- magnitudeVectorPtr += 4;
++- }
+++ magnitudeVectorPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- magnitudeVectorPtr = &magnitudeVector[number];
++- complexVectorPtr = (const int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- float val1Real = (float)(*complexVectorPtr++) * iScalar;
++- float val1Imag = (float)(*complexVectorPtr++) * iScalar;
++- *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
++- }
+++ number = quarterPoints * 4;
+++ magnitudeVectorPtr = &magnitudeVector[number];
+++ complexVectorPtr = (const int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ float val1Real = (float)(*complexVectorPtr++) * iScalar;
+++ float val1Imag = (float)(*complexVectorPtr++) * iScalar;
+++ *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
+++ }
++ }
++
++
++@@ -251,33 +254,37 @@ volk_16ic_s32f_magnitude_32f_a_sse(float* magnitudeVector, const lv_16sc_t* comp
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_16ic_s32f_magnitude_32f_generic(float* magnitudeVector, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16ic_s32f_magnitude_32f_generic(float* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++- unsigned int number = 0;
++- const float invScalar = 1.0 / scalar;
++- for(number = 0; number < num_points; number++){
++- float real = ( (float) (*complexVectorPtr++)) * invScalar;
++- float imag = ( (float) (*complexVectorPtr++)) * invScalar;
++- *magnitudeVectorPtr++ = sqrtf((real*real) + (imag*imag));
++- }
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++ unsigned int number = 0;
+++ const float invScalar = 1.0 / scalar;
+++ for (number = 0; number < num_points; number++) {
+++ float real = ((float)(*complexVectorPtr++)) * invScalar;
+++ float imag = ((float)(*complexVectorPtr++)) * invScalar;
+++ *magnitudeVectorPtr++ = sqrtf((real * real) + (imag * imag));
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_ORC_DISABLED
++
++-extern void
++-volk_16ic_s32f_magnitude_32f_a_orc_impl(float* magnitudeVector, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points);
+++extern void volk_16ic_s32f_magnitude_32f_a_orc_impl(float* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points);
++
++-static inline void
++-volk_16ic_s32f_magnitude_32f_u_orc(float* magnitudeVector, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16ic_s32f_magnitude_32f_u_orc(float* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- volk_16ic_s32f_magnitude_32f_a_orc_impl(magnitudeVector, complexVector, scalar, num_points);
+++ volk_16ic_s32f_magnitude_32f_a_orc_impl(
+++ magnitudeVector, complexVector, scalar, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++@@ -287,69 +294,69 @@ volk_16ic_s32f_magnitude_32f_u_orc(float* magnitudeVector, const lv_16sc_t* comp
++ #ifndef INCLUDED_volk_16ic_s32f_magnitude_32f_u_H
++ #define INCLUDED_volk_16ic_s32f_magnitude_32f_u_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_16ic_s32f_magnitude_32f_u_avx2(float* magnitudeVector, const lv_16sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_16ic_s32f_magnitude_32f_u_avx2(float* magnitudeVector,
+++ const lv_16sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const int16_t* complexVectorPtr = (const int16_t*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
++
++- const int16_t* complexVectorPtr = (const int16_t*)complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
+++ __m256 invScalar = _mm256_set1_ps(1.0 / scalar);
++
++- __m256 invScalar = _mm256_set1_ps(1.0/scalar);
+++ __m256 cplxValue1, cplxValue2, result;
+++ __m256i int1, int2;
+++ __m128i short1, short2;
+++ __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
++
++- __m256 cplxValue1, cplxValue2, result;
++- __m256i int1, int2;
++- __m128i short1, short2;
++- __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
+++ for (; number < eighthPoints; number++) {
++
++- for(;number < eighthPoints; number++){
++-
++- int1 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
++- complexVectorPtr += 16;
++- short1 = _mm256_extracti128_si256(int1,0);
++- short2 = _mm256_extracti128_si256(int1,1);
+++ int1 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++ short1 = _mm256_extracti128_si256(int1, 0);
+++ short2 = _mm256_extracti128_si256(int1, 1);
++
++- int1 = _mm256_cvtepi16_epi32(short1);
++- int2 = _mm256_cvtepi16_epi32(short2);
++- cplxValue1 = _mm256_cvtepi32_ps(int1);
++- cplxValue2 = _mm256_cvtepi32_ps(int2);
+++ int1 = _mm256_cvtepi16_epi32(short1);
+++ int2 = _mm256_cvtepi16_epi32(short2);
+++ cplxValue1 = _mm256_cvtepi32_ps(int1);
+++ cplxValue2 = _mm256_cvtepi32_ps(int2);
++
++- cplxValue1 = _mm256_mul_ps(cplxValue1, invScalar);
++- cplxValue2 = _mm256_mul_ps(cplxValue2, invScalar);
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, invScalar);
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, invScalar);
++
++- cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
++- cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
++
++- result = _mm256_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
++- result = _mm256_permutevar8x32_ps(result, idx);
+++ result = _mm256_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
+++ result = _mm256_permutevar8x32_ps(result, idx);
++
++- result = _mm256_sqrt_ps(result); // Square root the values
+++ result = _mm256_sqrt_ps(result); // Square root the values
++
++- _mm256_storeu_ps(magnitudeVectorPtr, result);
+++ _mm256_storeu_ps(magnitudeVectorPtr, result);
++
++- magnitudeVectorPtr += 8;
++- }
+++ magnitudeVectorPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- magnitudeVectorPtr = &magnitudeVector[number];
++- complexVectorPtr = (const int16_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- float val1Real = (float)(*complexVectorPtr++) / scalar;
++- float val1Imag = (float)(*complexVectorPtr++) / scalar;
++- *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
++- }
+++ number = eighthPoints * 8;
+++ magnitudeVectorPtr = &magnitudeVector[number];
+++ complexVectorPtr = (const int16_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ float val1Real = (float)(*complexVectorPtr++) / scalar;
+++ float val1Imag = (float)(*complexVectorPtr++) / scalar;
+++ *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #endif /* INCLUDED_volk_16ic_s32f_magnitude_32f_u_H */
++-
++diff --git a/kernels/volk/volk_16ic_x2_dot_prod_16ic.h b/kernels/volk/volk_16ic_x2_dot_prod_16ic.h
++index ae10cff..a1a0e8c 100644
++--- a/kernels/volk/volk_16ic_x2_dot_prod_16ic.h
+++++ b/kernels/volk/volk_16ic_x2_dot_prod_16ic.h
++@@ -25,18 +25,20 @@
++ *
++ * \b Overview
++ *
++- * Multiplies two input complex vectors (16-bit integer each component) and accumulates them,
++- * storing the result. Results are saturated so never go beyond the limits of the data type.
+++ * Multiplies two input complex vectors (16-bit integer each component) and accumulates
+++ * them, storing the result. Results are saturated so never go beyond the limits of the
+++ * data type.
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16ic_x2_dot_prod_16ic(lv_16sc_t* result, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points);
++- * \endcode
+++ * void volk_16ic_x2_dot_prod_16ic(lv_16sc_t* result, const lv_16sc_t* in_a, const
+++ * lv_16sc_t* in_b, unsigned int num_points); \endcode
++ *
++ * \b Inputs
++ * \li in_a: One of the vectors to be multiplied and accumulated.
++ * \li in_b: The other vector to be multiplied and accumulated.
++- * \li num_points: Number of complex values to be multiplied together, accumulated and stored into \p result
+++ * \li num_points: Number of complex values to be multiplied together, accumulated and
+++ * stored into \p result
++ *
++ * \b Outputs
++ * \li result: Value of the accumulated result.
++@@ -46,22 +48,25 @@
++ #ifndef INCLUDED_volk_16ic_x2_dot_prod_16ic_H
++ #define INCLUDED_volk_16ic_x2_dot_prod_16ic_H
++
+++#include <volk/saturation_arithmetic.h>
++ #include <volk/volk_common.h>
++ #include <volk/volk_complex.h>
++-#include <volk/saturation_arithmetic.h>
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_16ic_x2_dot_prod_16ic_generic(lv_16sc_t* result, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_dot_prod_16ic_generic(lv_16sc_t* result,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++ result[0] = lv_cmake((int16_t)0, (int16_t)0);
++ unsigned int n;
++- for (n = 0; n < num_points; n++)
++- {
++- lv_16sc_t tmp = in_a[n] * in_b[n];
++- result[0] = lv_cmake(sat_adds16i(lv_creal(result[0]), lv_creal(tmp)), sat_adds16i(lv_cimag(result[0]), lv_cimag(tmp) ));
++- }
+++ for (n = 0; n < num_points; n++) {
+++ lv_16sc_t tmp = in_a[n] * in_b[n];
+++ result[0] = lv_cmake(sat_adds16i(lv_creal(result[0]), lv_creal(tmp)),
+++ sat_adds16i(lv_cimag(result[0]), lv_cimag(tmp)));
+++ }
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -70,7 +75,10 @@ static inline void volk_16ic_x2_dot_prod_16ic_generic(lv_16sc_t* result, const l
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_16ic_x2_dot_prod_16ic_a_sse2(lv_16sc_t* out, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_dot_prod_16ic_a_sse2(lv_16sc_t* out,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++ lv_16sc_t dotProduct = lv_cmake((int16_t)0, (int16_t)0);
++
++@@ -81,62 +89,67 @@ static inline void volk_16ic_x2_dot_prod_16ic_a_sse2(lv_16sc_t* out, const lv_16
++ const lv_16sc_t* _in_b = in_b;
++ lv_16sc_t* _out = out;
++
++- if (sse_iters > 0)
++- {
++- __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl, realcacc, imagcacc;
++- __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
+++ if (sse_iters > 0) {
+++ __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl,
+++ realcacc, imagcacc;
+++ __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
++
++- realcacc = _mm_setzero_si128();
++- imagcacc = _mm_setzero_si128();
+++ realcacc = _mm_setzero_si128();
+++ imagcacc = _mm_setzero_si128();
++
++- mask_imag = _mm_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
++- mask_real = _mm_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
+++ mask_imag = _mm_set_epi8(
+++ 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
+++ mask_real = _mm_set_epi8(
+++ 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
++
++- for(number = 0; number < sse_iters; number++)
++- {
++- // a[127:0]=[a3.i,a3.r,a2.i,a2.r,a1.i,a1.r,a0.i,a0.r]
++- a = _mm_load_si128((__m128i*)_in_a); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
++- __VOLK_PREFETCH(_in_a + 8);
++- b = _mm_load_si128((__m128i*)_in_b);
++- __VOLK_PREFETCH(_in_b + 8);
++- c = _mm_mullo_epi16(a, b); // a3.i*b3.i, a3.r*b3.r, ....
+++ for (number = 0; number < sse_iters; number++) {
+++ // a[127:0]=[a3.i,a3.r,a2.i,a2.r,a1.i,a1.r,a0.i,a0.r]
+++ a = _mm_load_si128(
+++ (__m128i*)_in_a); // load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+++ __VOLK_PREFETCH(_in_a + 8);
+++ b = _mm_load_si128((__m128i*)_in_b);
+++ __VOLK_PREFETCH(_in_b + 8);
+++ c = _mm_mullo_epi16(a, b); // a3.i*b3.i, a3.r*b3.r, ....
++
++- c_sr = _mm_srli_si128(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
++- real = _mm_subs_epi16(c, c_sr);
+++ c_sr = _mm_srli_si128(c, 2); // Shift a right by imm8 bytes while shifting in
+++ // zeros, and store the results in dst.
+++ real = _mm_subs_epi16(c, c_sr);
++
++- b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
++- a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
+++ b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
+++ a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
++
++- imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
++- imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+++ imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
+++ imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
++
++- imag = _mm_adds_epi16(imag1, imag2); //with saturation arithmetic!
+++ imag = _mm_adds_epi16(imag1, imag2); // with saturation arithmetic!
++
++- realcacc = _mm_adds_epi16(realcacc, real);
++- imagcacc = _mm_adds_epi16(imagcacc, imag);
+++ realcacc = _mm_adds_epi16(realcacc, real);
+++ imagcacc = _mm_adds_epi16(imagcacc, imag);
++
++- _in_a += 4;
++- _in_b += 4;
++- }
+++ _in_a += 4;
+++ _in_b += 4;
+++ }
++
++- realcacc = _mm_and_si128(realcacc, mask_real);
++- imagcacc = _mm_and_si128(imagcacc, mask_imag);
+++ realcacc = _mm_and_si128(realcacc, mask_real);
+++ imagcacc = _mm_and_si128(imagcacc, mask_imag);
++
++- a = _mm_or_si128(realcacc, imagcacc);
+++ a = _mm_or_si128(realcacc, imagcacc);
++
++- _mm_store_si128((__m128i*)dotProductVector, a); // Store the results back into the dot product vector
+++ _mm_store_si128((__m128i*)dotProductVector,
+++ a); // Store the results back into the dot product vector
++
++- for (number = 0; number < 4; ++number)
++- {
++- dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[number])), sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[number])));
++- }
+++ for (number = 0; number < 4; ++number) {
+++ dotProduct = lv_cmake(
+++ sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[number])),
+++ sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[number])));
++ }
+++ }
++
++- for (number = 0; number < (num_points % 4); ++number)
++- {
++- lv_16sc_t tmp = (*_in_a++) * (*_in_b++);
++- dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(tmp)), sat_adds16i(lv_cimag(dotProduct), lv_cimag(tmp)));
++- }
+++ for (number = 0; number < (num_points % 4); ++number) {
+++ lv_16sc_t tmp = (*_in_a++) * (*_in_b++);
+++ dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(tmp)),
+++ sat_adds16i(lv_cimag(dotProduct), lv_cimag(tmp)));
+++ }
++
++ *_out = dotProduct;
++ }
++@@ -147,7 +160,10 @@ static inline void volk_16ic_x2_dot_prod_16ic_a_sse2(lv_16sc_t* out, const lv_16
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_16ic_x2_dot_prod_16ic_u_sse2(lv_16sc_t* out, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_dot_prod_16ic_u_sse2(lv_16sc_t* out,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++ lv_16sc_t dotProduct = lv_cmake((int16_t)0, (int16_t)0);
++
++@@ -158,62 +174,67 @@ static inline void volk_16ic_x2_dot_prod_16ic_u_sse2(lv_16sc_t* out, const lv_16
++ lv_16sc_t* _out = out;
++ unsigned int number;
++
++- if (sse_iters > 0)
++- {
++- __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl, realcacc, imagcacc, result;
++- __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
+++ if (sse_iters > 0) {
+++ __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl,
+++ realcacc, imagcacc, result;
+++ __VOLK_ATTR_ALIGNED(16) lv_16sc_t dotProductVector[4];
++
++- realcacc = _mm_setzero_si128();
++- imagcacc = _mm_setzero_si128();
+++ realcacc = _mm_setzero_si128();
+++ imagcacc = _mm_setzero_si128();
++
++- mask_imag = _mm_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
++- mask_real = _mm_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
+++ mask_imag = _mm_set_epi8(
+++ 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
+++ mask_real = _mm_set_epi8(
+++ 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
++
++- for(number = 0; number < sse_iters; number++)
++- {
++- // a[127:0]=[a3.i,a3.r,a2.i,a2.r,a1.i,a1.r,a0.i,a0.r]
++- a = _mm_loadu_si128((__m128i*)_in_a); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
++- __VOLK_PREFETCH(_in_a + 8);
++- b = _mm_loadu_si128((__m128i*)_in_b);
++- __VOLK_PREFETCH(_in_b + 8);
++- c = _mm_mullo_epi16(a, b); // a3.i*b3.i, a3.r*b3.r, ....
+++ for (number = 0; number < sse_iters; number++) {
+++ // a[127:0]=[a3.i,a3.r,a2.i,a2.r,a1.i,a1.r,a0.i,a0.r]
+++ a = _mm_loadu_si128(
+++ (__m128i*)_in_a); // load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+++ __VOLK_PREFETCH(_in_a + 8);
+++ b = _mm_loadu_si128((__m128i*)_in_b);
+++ __VOLK_PREFETCH(_in_b + 8);
+++ c = _mm_mullo_epi16(a, b); // a3.i*b3.i, a3.r*b3.r, ....
++
++- c_sr = _mm_srli_si128(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
++- real = _mm_subs_epi16(c, c_sr);
+++ c_sr = _mm_srli_si128(c, 2); // Shift a right by imm8 bytes while shifting in
+++ // zeros, and store the results in dst.
+++ real = _mm_subs_epi16(c, c_sr);
++
++- b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
++- a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
+++ b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
+++ a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
++
++- imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
++- imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+++ imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
+++ imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
++
++- imag = _mm_adds_epi16(imag1, imag2); //with saturation arithmetic!
+++ imag = _mm_adds_epi16(imag1, imag2); // with saturation arithmetic!
++
++- realcacc = _mm_adds_epi16(realcacc, real);
++- imagcacc = _mm_adds_epi16(imagcacc, imag);
+++ realcacc = _mm_adds_epi16(realcacc, real);
+++ imagcacc = _mm_adds_epi16(imagcacc, imag);
++
++- _in_a += 4;
++- _in_b += 4;
++- }
+++ _in_a += 4;
+++ _in_b += 4;
+++ }
++
++- realcacc = _mm_and_si128(realcacc, mask_real);
++- imagcacc = _mm_and_si128(imagcacc, mask_imag);
+++ realcacc = _mm_and_si128(realcacc, mask_real);
+++ imagcacc = _mm_and_si128(imagcacc, mask_imag);
++
++- result = _mm_or_si128(realcacc, imagcacc);
+++ result = _mm_or_si128(realcacc, imagcacc);
++
++- _mm_storeu_si128((__m128i*)dotProductVector, result); // Store the results back into the dot product vector
+++ _mm_storeu_si128((__m128i*)dotProductVector,
+++ result); // Store the results back into the dot product vector
++
++- for (number = 0; number < 4; ++number)
++- {
++- dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[number])), sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[number])));
++- }
+++ for (number = 0; number < 4; ++number) {
+++ dotProduct = lv_cmake(
+++ sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[number])),
+++ sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[number])));
++ }
+++ }
++
++- for (number = 0; number < (num_points % 4); ++number)
++- {
++- lv_16sc_t tmp = (*_in_a++) * (*_in_b++);
++- dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(tmp)), sat_adds16i(lv_cimag(dotProduct), lv_cimag(tmp)));
++- }
+++ for (number = 0; number < (num_points % 4); ++number) {
+++ lv_16sc_t tmp = (*_in_a++) * (*_in_b++);
+++ dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(tmp)),
+++ sat_adds16i(lv_cimag(dotProduct), lv_cimag(tmp)));
+++ }
++
++ *_out = dotProduct;
++ }
++@@ -223,7 +244,10 @@ static inline void volk_16ic_x2_dot_prod_16ic_u_sse2(lv_16sc_t* out, const lv_16
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void volk_16ic_x2_dot_prod_16ic_u_axv2(lv_16sc_t* out, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_dot_prod_16ic_u_axv2(lv_16sc_t* out,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++ lv_16sc_t dotProduct = lv_cmake((int16_t)0, (int16_t)0);
++
++@@ -234,62 +258,126 @@ static inline void volk_16ic_x2_dot_prod_16ic_u_axv2(lv_16sc_t* out, const lv_16
++ lv_16sc_t* _out = out;
++ unsigned int number;
++
++- if (avx_iters > 0)
++- {
++- __m256i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl, realcacc, imagcacc, result;
++- __VOLK_ATTR_ALIGNED(32) lv_16sc_t dotProductVector[8];
++-
++- realcacc = _mm256_setzero_si256();
++- imagcacc = _mm256_setzero_si256();
++-
++- mask_imag = _mm256_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
++- mask_real = _mm256_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
++-
++- for(number = 0; number < avx_iters; number++)
++- {
++- a = _mm256_loadu_si256((__m256i*)_in_a);
++- __VOLK_PREFETCH(_in_a + 16);
++- b = _mm256_loadu_si256((__m256i*)_in_b);
++- __VOLK_PREFETCH(_in_b + 16);
++- c = _mm256_mullo_epi16(a, b);
++-
++- c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
++- real = _mm256_subs_epi16(c, c_sr);
++-
++- b_sl = _mm256_slli_si256(b, 2);
++- a_sl = _mm256_slli_si256(a, 2);
++-
++- imag1 = _mm256_mullo_epi16(a, b_sl);
++- imag2 = _mm256_mullo_epi16(b, a_sl);
++-
++- imag = _mm256_adds_epi16(imag1, imag2); //with saturation arithmetic!
++-
++- realcacc = _mm256_adds_epi16(realcacc, real);
++- imagcacc = _mm256_adds_epi16(imagcacc, imag);
++-
++- _in_a += 8;
++- _in_b += 8;
++- }
+++ if (avx_iters > 0) {
+++ __m256i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl,
+++ realcacc, imagcacc, result;
+++ __VOLK_ATTR_ALIGNED(32) lv_16sc_t dotProductVector[8];
+++
+++ realcacc = _mm256_setzero_si256();
+++ imagcacc = _mm256_setzero_si256();
+++
+++ mask_imag = _mm256_set_epi8(0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0);
+++ mask_real = _mm256_set_epi8(0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF);
+++
+++ for (number = 0; number < avx_iters; number++) {
+++ a = _mm256_loadu_si256((__m256i*)_in_a);
+++ __VOLK_PREFETCH(_in_a + 16);
+++ b = _mm256_loadu_si256((__m256i*)_in_b);
+++ __VOLK_PREFETCH(_in_b + 16);
+++ c = _mm256_mullo_epi16(a, b);
+++
+++ c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting
+++ // in zeros, and store the results in dst.
+++ real = _mm256_subs_epi16(c, c_sr);
+++
+++ b_sl = _mm256_slli_si256(b, 2);
+++ a_sl = _mm256_slli_si256(a, 2);
+++
+++ imag1 = _mm256_mullo_epi16(a, b_sl);
+++ imag2 = _mm256_mullo_epi16(b, a_sl);
+++
+++ imag = _mm256_adds_epi16(imag1, imag2); // with saturation arithmetic!
+++
+++ realcacc = _mm256_adds_epi16(realcacc, real);
+++ imagcacc = _mm256_adds_epi16(imagcacc, imag);
+++
+++ _in_a += 8;
+++ _in_b += 8;
+++ }
++
++- realcacc = _mm256_and_si256(realcacc, mask_real);
++- imagcacc = _mm256_and_si256(imagcacc, mask_imag);
+++ realcacc = _mm256_and_si256(realcacc, mask_real);
+++ imagcacc = _mm256_and_si256(imagcacc, mask_imag);
++
++- result = _mm256_or_si256(realcacc, imagcacc);
+++ result = _mm256_or_si256(realcacc, imagcacc);
++
++- _mm256_storeu_si256((__m256i*)dotProductVector, result); // Store the results back into the dot product vector
++- _mm256_zeroupper();
+++ _mm256_storeu_si256((__m256i*)dotProductVector,
+++ result); // Store the results back into the dot product vector
+++ _mm256_zeroupper();
++
++- for (number = 0; number < 8; ++number)
++- {
++- dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[number])), sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[number])));
++- }
+++ for (number = 0; number < 8; ++number) {
+++ dotProduct = lv_cmake(
+++ sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[number])),
+++ sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[number])));
++ }
+++ }
++
++- for (number = 0; number < (num_points % 8); ++number)
++- {
++- lv_16sc_t tmp = (*_in_a++) * (*_in_b++);
++- dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(tmp)), sat_adds16i(lv_cimag(dotProduct), lv_cimag(tmp)));
++- }
+++ for (number = 0; number < (num_points % 8); ++number) {
+++ lv_16sc_t tmp = (*_in_a++) * (*_in_b++);
+++ dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(tmp)),
+++ sat_adds16i(lv_cimag(dotProduct), lv_cimag(tmp)));
+++ }
++
++ *_out = dotProduct;
++ }
++@@ -299,7 +387,10 @@ static inline void volk_16ic_x2_dot_prod_16ic_u_axv2(lv_16sc_t* out, const lv_16
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void volk_16ic_x2_dot_prod_16ic_a_axv2(lv_16sc_t* out, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_dot_prod_16ic_a_axv2(lv_16sc_t* out,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++ lv_16sc_t dotProduct = lv_cmake((int16_t)0, (int16_t)0);
++
++@@ -310,62 +401,126 @@ static inline void volk_16ic_x2_dot_prod_16ic_a_axv2(lv_16sc_t* out, const lv_16
++ lv_16sc_t* _out = out;
++ unsigned int number;
++
++- if (avx_iters > 0)
++- {
++- __m256i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl, realcacc, imagcacc, result;
++- __VOLK_ATTR_ALIGNED(32) lv_16sc_t dotProductVector[8];
++-
++- realcacc = _mm256_setzero_si256();
++- imagcacc = _mm256_setzero_si256();
++-
++- mask_imag = _mm256_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
++- mask_real = _mm256_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
++-
++- for(number = 0; number < avx_iters; number++)
++- {
++- a = _mm256_load_si256((__m256i*)_in_a);
++- __VOLK_PREFETCH(_in_a + 16);
++- b = _mm256_load_si256((__m256i*)_in_b);
++- __VOLK_PREFETCH(_in_b + 16);
++- c = _mm256_mullo_epi16(a, b);
++-
++- c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
++- real = _mm256_subs_epi16(c, c_sr);
++-
++- b_sl = _mm256_slli_si256(b, 2);
++- a_sl = _mm256_slli_si256(a, 2);
++-
++- imag1 = _mm256_mullo_epi16(a, b_sl);
++- imag2 = _mm256_mullo_epi16(b, a_sl);
++-
++- imag = _mm256_adds_epi16(imag1, imag2); //with saturation arithmetic!
++-
++- realcacc = _mm256_adds_epi16(realcacc, real);
++- imagcacc = _mm256_adds_epi16(imagcacc, imag);
++-
++- _in_a += 8;
++- _in_b += 8;
++- }
+++ if (avx_iters > 0) {
+++ __m256i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl,
+++ realcacc, imagcacc, result;
+++ __VOLK_ATTR_ALIGNED(32) lv_16sc_t dotProductVector[8];
+++
+++ realcacc = _mm256_setzero_si256();
+++ imagcacc = _mm256_setzero_si256();
+++
+++ mask_imag = _mm256_set_epi8(0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0);
+++ mask_real = _mm256_set_epi8(0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF);
+++
+++ for (number = 0; number < avx_iters; number++) {
+++ a = _mm256_load_si256((__m256i*)_in_a);
+++ __VOLK_PREFETCH(_in_a + 16);
+++ b = _mm256_load_si256((__m256i*)_in_b);
+++ __VOLK_PREFETCH(_in_b + 16);
+++ c = _mm256_mullo_epi16(a, b);
+++
+++ c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting
+++ // in zeros, and store the results in dst.
+++ real = _mm256_subs_epi16(c, c_sr);
+++
+++ b_sl = _mm256_slli_si256(b, 2);
+++ a_sl = _mm256_slli_si256(a, 2);
+++
+++ imag1 = _mm256_mullo_epi16(a, b_sl);
+++ imag2 = _mm256_mullo_epi16(b, a_sl);
+++
+++ imag = _mm256_adds_epi16(imag1, imag2); // with saturation arithmetic!
+++
+++ realcacc = _mm256_adds_epi16(realcacc, real);
+++ imagcacc = _mm256_adds_epi16(imagcacc, imag);
+++
+++ _in_a += 8;
+++ _in_b += 8;
+++ }
++
++- realcacc = _mm256_and_si256(realcacc, mask_real);
++- imagcacc = _mm256_and_si256(imagcacc, mask_imag);
+++ realcacc = _mm256_and_si256(realcacc, mask_real);
+++ imagcacc = _mm256_and_si256(imagcacc, mask_imag);
++
++- result = _mm256_or_si256(realcacc, imagcacc);
+++ result = _mm256_or_si256(realcacc, imagcacc);
++
++- _mm256_store_si256((__m256i*)dotProductVector, result); // Store the results back into the dot product vector
++- _mm256_zeroupper();
+++ _mm256_store_si256((__m256i*)dotProductVector,
+++ result); // Store the results back into the dot product vector
+++ _mm256_zeroupper();
++
++- for (number = 0; number < 8; ++number)
++- {
++- dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[number])), sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[number])));
++- }
+++ for (number = 0; number < 8; ++number) {
+++ dotProduct = lv_cmake(
+++ sat_adds16i(lv_creal(dotProduct), lv_creal(dotProductVector[number])),
+++ sat_adds16i(lv_cimag(dotProduct), lv_cimag(dotProductVector[number])));
++ }
+++ }
++
++- for (number = 0; number < (num_points % 8); ++number)
++- {
++- lv_16sc_t tmp = (*_in_a++) * (*_in_b++);
++- dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(tmp)), sat_adds16i(lv_cimag(dotProduct), lv_cimag(tmp)));
++- }
+++ for (number = 0; number < (num_points % 8); ++number) {
+++ lv_16sc_t tmp = (*_in_a++) * (*_in_b++);
+++ dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(tmp)),
+++ sat_adds16i(lv_cimag(dotProduct), lv_cimag(tmp)));
+++ }
++
++ *_out = dotProduct;
++ }
++@@ -375,69 +530,70 @@ static inline void volk_16ic_x2_dot_prod_16ic_a_axv2(lv_16sc_t* out, const lv_16
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_16ic_x2_dot_prod_16ic_neon(lv_16sc_t* out, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_dot_prod_16ic_neon(lv_16sc_t* out,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++ unsigned int quarter_points = num_points / 4;
++ unsigned int number;
++
++- lv_16sc_t* a_ptr = (lv_16sc_t*) in_a;
++- lv_16sc_t* b_ptr = (lv_16sc_t*) in_b;
+++ lv_16sc_t* a_ptr = (lv_16sc_t*)in_a;
+++ lv_16sc_t* b_ptr = (lv_16sc_t*)in_b;
++ *out = lv_cmake((int16_t)0, (int16_t)0);
++
++- if (quarter_points > 0)
++- {
++- // for 2-lane vectors, 1st lane holds the real part,
++- // 2nd lane holds the imaginary part
++- int16x4x2_t a_val, b_val, c_val, accumulator;
++- int16x4x2_t tmp_real, tmp_imag;
++- __VOLK_ATTR_ALIGNED(16) lv_16sc_t accum_result[4];
++- accumulator.val[0] = vdup_n_s16(0);
++- accumulator.val[1] = vdup_n_s16(0);
++- lv_16sc_t dotProduct = lv_cmake((int16_t)0, (int16_t)0);
++-
++- for(number = 0; number < quarter_points; ++number)
++- {
++- a_val = vld2_s16((int16_t*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
++- b_val = vld2_s16((int16_t*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
++- __VOLK_PREFETCH(a_ptr + 8);
++- __VOLK_PREFETCH(b_ptr + 8);
++-
++- // multiply the real*real and imag*imag to get real result
++- // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
++- tmp_real.val[0] = vmul_s16(a_val.val[0], b_val.val[0]);
++- // a0i*b0i|a1i*b1i|a2i*b2i|a3i*b3i
++- tmp_real.val[1] = vmul_s16(a_val.val[1], b_val.val[1]);
++-
++- // Multiply cross terms to get the imaginary result
++- // a0r*b0i|a1r*b1i|a2r*b2i|a3r*b3i
++- tmp_imag.val[0] = vmul_s16(a_val.val[0], b_val.val[1]);
++- // a0i*b0r|a1i*b1r|a2i*b2r|a3i*b3r
++- tmp_imag.val[1] = vmul_s16(a_val.val[1], b_val.val[0]);
++-
++- c_val.val[0] = vqsub_s16(tmp_real.val[0], tmp_real.val[1]);
++- c_val.val[1] = vqadd_s16(tmp_imag.val[0], tmp_imag.val[1]);
++-
++- accumulator.val[0] = vqadd_s16(accumulator.val[0], c_val.val[0]);
++- accumulator.val[1] = vqadd_s16(accumulator.val[1], c_val.val[1]);
++-
++- a_ptr += 4;
++- b_ptr += 4;
++- }
++-
++- vst2_s16((int16_t*)accum_result, accumulator);
++- for (number = 0; number < 4; ++number)
++- {
++- dotProduct = lv_cmake(sat_adds16i(lv_creal(dotProduct), lv_creal(accum_result[number])), sat_adds16i(lv_cimag(dotProduct), lv_cimag(accum_result[number])));
++- }
++-
++- *out = dotProduct;
+++ if (quarter_points > 0) {
+++ // for 2-lane vectors, 1st lane holds the real part,
+++ // 2nd lane holds the imaginary part
+++ int16x4x2_t a_val, b_val, c_val, accumulator;
+++ int16x4x2_t tmp_real, tmp_imag;
+++ __VOLK_ATTR_ALIGNED(16) lv_16sc_t accum_result[4];
+++ accumulator.val[0] = vdup_n_s16(0);
+++ accumulator.val[1] = vdup_n_s16(0);
+++ lv_16sc_t dotProduct = lv_cmake((int16_t)0, (int16_t)0);
+++
+++ for (number = 0; number < quarter_points; ++number) {
+++ a_val = vld2_s16((int16_t*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
+++ b_val = vld2_s16((int16_t*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
+++ __VOLK_PREFETCH(a_ptr + 8);
+++ __VOLK_PREFETCH(b_ptr + 8);
+++
+++ // multiply the real*real and imag*imag to get real result
+++ // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
+++ tmp_real.val[0] = vmul_s16(a_val.val[0], b_val.val[0]);
+++ // a0i*b0i|a1i*b1i|a2i*b2i|a3i*b3i
+++ tmp_real.val[1] = vmul_s16(a_val.val[1], b_val.val[1]);
+++
+++ // Multiply cross terms to get the imaginary result
+++ // a0r*b0i|a1r*b1i|a2r*b2i|a3r*b3i
+++ tmp_imag.val[0] = vmul_s16(a_val.val[0], b_val.val[1]);
+++ // a0i*b0r|a1i*b1r|a2i*b2r|a3i*b3r
+++ tmp_imag.val[1] = vmul_s16(a_val.val[1], b_val.val[0]);
+++
+++ c_val.val[0] = vqsub_s16(tmp_real.val[0], tmp_real.val[1]);
+++ c_val.val[1] = vqadd_s16(tmp_imag.val[0], tmp_imag.val[1]);
+++
+++ accumulator.val[0] = vqadd_s16(accumulator.val[0], c_val.val[0]);
+++ accumulator.val[1] = vqadd_s16(accumulator.val[1], c_val.val[1]);
+++
+++ a_ptr += 4;
+++ b_ptr += 4;
++ }
++
++- // tail case
++- for(number = quarter_points * 4; number < num_points; ++number)
++- {
++- *out += (*a_ptr++) * (*b_ptr++);
+++ vst2_s16((int16_t*)accum_result, accumulator);
+++ for (number = 0; number < 4; ++number) {
+++ dotProduct = lv_cmake(
+++ sat_adds16i(lv_creal(dotProduct), lv_creal(accum_result[number])),
+++ sat_adds16i(lv_cimag(dotProduct), lv_cimag(accum_result[number])));
++ }
+++
+++ *out = dotProduct;
+++ }
+++
+++ // tail case
+++ for (number = quarter_points * 4; number < num_points; ++number) {
+++ *out += (*a_ptr++) * (*b_ptr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_NEON */
++@@ -446,13 +602,16 @@ static inline void volk_16ic_x2_dot_prod_16ic_neon(lv_16sc_t* out, const lv_16sc
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_16ic_x2_dot_prod_16ic_neon_vma(lv_16sc_t* out, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_dot_prod_16ic_neon_vma(lv_16sc_t* out,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++ unsigned int quarter_points = num_points / 4;
++ unsigned int number;
++
++- lv_16sc_t* a_ptr = (lv_16sc_t*) in_a;
++- lv_16sc_t* b_ptr = (lv_16sc_t*) in_b;
+++ lv_16sc_t* a_ptr = (lv_16sc_t*)in_a;
+++ lv_16sc_t* b_ptr = (lv_16sc_t*)in_b;
++ // for 2-lane vectors, 1st lane holds the real part,
++ // 2nd lane holds the imaginary part
++ int16x4x2_t a_val, b_val, accumulator;
++@@ -461,35 +620,33 @@ static inline void volk_16ic_x2_dot_prod_16ic_neon_vma(lv_16sc_t* out, const lv_
++ accumulator.val[0] = vdup_n_s16(0);
++ accumulator.val[1] = vdup_n_s16(0);
++
++- for(number = 0; number < quarter_points; ++number)
++- {
++- a_val = vld2_s16((int16_t*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
++- b_val = vld2_s16((int16_t*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
++- __VOLK_PREFETCH(a_ptr + 8);
++- __VOLK_PREFETCH(b_ptr + 8);
+++ for (number = 0; number < quarter_points; ++number) {
+++ a_val = vld2_s16((int16_t*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
+++ b_val = vld2_s16((int16_t*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
+++ __VOLK_PREFETCH(a_ptr + 8);
+++ __VOLK_PREFETCH(b_ptr + 8);
++
++- tmp.val[0] = vmul_s16(a_val.val[0], b_val.val[0]);
++- tmp.val[1] = vmul_s16(a_val.val[1], b_val.val[0]);
+++ tmp.val[0] = vmul_s16(a_val.val[0], b_val.val[0]);
+++ tmp.val[1] = vmul_s16(a_val.val[1], b_val.val[0]);
++
++- // use multiply accumulate/subtract to get result
++- tmp.val[0] = vmls_s16(tmp.val[0], a_val.val[1], b_val.val[1]);
++- tmp.val[1] = vmla_s16(tmp.val[1], a_val.val[0], b_val.val[1]);
+++ // use multiply accumulate/subtract to get result
+++ tmp.val[0] = vmls_s16(tmp.val[0], a_val.val[1], b_val.val[1]);
+++ tmp.val[1] = vmla_s16(tmp.val[1], a_val.val[0], b_val.val[1]);
++
++- accumulator.val[0] = vqadd_s16(accumulator.val[0], tmp.val[0]);
++- accumulator.val[1] = vqadd_s16(accumulator.val[1], tmp.val[1]);
+++ accumulator.val[0] = vqadd_s16(accumulator.val[0], tmp.val[0]);
+++ accumulator.val[1] = vqadd_s16(accumulator.val[1], tmp.val[1]);
++
++- a_ptr += 4;
++- b_ptr += 4;
++- }
+++ a_ptr += 4;
+++ b_ptr += 4;
+++ }
++
++ vst2_s16((int16_t*)accum_result, accumulator);
++ *out = accum_result[0] + accum_result[1] + accum_result[2] + accum_result[3];
++
++ // tail case
++- for(number = quarter_points * 4; number < num_points; ++number)
++- {
++- *out += (*a_ptr++) * (*b_ptr++);
++- }
+++ for (number = quarter_points * 4; number < num_points; ++number) {
+++ *out += (*a_ptr++) * (*b_ptr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_NEON */
++@@ -498,13 +655,16 @@ static inline void volk_16ic_x2_dot_prod_16ic_neon_vma(lv_16sc_t* out, const lv_
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_16ic_x2_dot_prod_16ic_neon_optvma(lv_16sc_t* out, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_dot_prod_16ic_neon_optvma(lv_16sc_t* out,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++ unsigned int quarter_points = num_points / 4;
++ unsigned int number;
++
++- lv_16sc_t* a_ptr = (lv_16sc_t*) in_a;
++- lv_16sc_t* b_ptr = (lv_16sc_t*) in_b;
+++ lv_16sc_t* a_ptr = (lv_16sc_t*)in_a;
+++ lv_16sc_t* b_ptr = (lv_16sc_t*)in_b;
++ // for 2-lane vectors, 1st lane holds the real part,
++ // 2nd lane holds the imaginary part
++ int16x4x2_t a_val, b_val, accumulator1, accumulator2;
++@@ -515,22 +675,21 @@ static inline void volk_16ic_x2_dot_prod_16ic_neon_optvma(lv_16sc_t* out, const
++ accumulator2.val[0] = vdup_n_s16(0);
++ accumulator2.val[1] = vdup_n_s16(0);
++
++- for(number = 0; number < quarter_points; ++number)
++- {
++- a_val = vld2_s16((int16_t*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
++- b_val = vld2_s16((int16_t*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
++- __VOLK_PREFETCH(a_ptr + 8);
++- __VOLK_PREFETCH(b_ptr + 8);
+++ for (number = 0; number < quarter_points; ++number) {
+++ a_val = vld2_s16((int16_t*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
+++ b_val = vld2_s16((int16_t*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
+++ __VOLK_PREFETCH(a_ptr + 8);
+++ __VOLK_PREFETCH(b_ptr + 8);
++
++- // use 2 accumulators to remove inter-instruction data dependencies
++- accumulator1.val[0] = vmla_s16(accumulator1.val[0], a_val.val[0], b_val.val[0]);
++- accumulator2.val[0] = vmls_s16(accumulator2.val[0], a_val.val[1], b_val.val[1]);
++- accumulator1.val[1] = vmla_s16(accumulator1.val[1], a_val.val[0], b_val.val[1]);
++- accumulator2.val[1] = vmla_s16(accumulator2.val[1], a_val.val[1], b_val.val[0]);
+++ // use 2 accumulators to remove inter-instruction data dependencies
+++ accumulator1.val[0] = vmla_s16(accumulator1.val[0], a_val.val[0], b_val.val[0]);
+++ accumulator2.val[0] = vmls_s16(accumulator2.val[0], a_val.val[1], b_val.val[1]);
+++ accumulator1.val[1] = vmla_s16(accumulator1.val[1], a_val.val[0], b_val.val[1]);
+++ accumulator2.val[1] = vmla_s16(accumulator2.val[1], a_val.val[1], b_val.val[0]);
++
++- a_ptr += 4;
++- b_ptr += 4;
++- }
+++ a_ptr += 4;
+++ b_ptr += 4;
+++ }
++
++ accumulator1.val[0] = vqadd_s16(accumulator1.val[0], accumulator2.val[0]);
++ accumulator1.val[1] = vqadd_s16(accumulator1.val[1], accumulator2.val[1]);
++@@ -539,10 +698,9 @@ static inline void volk_16ic_x2_dot_prod_16ic_neon_optvma(lv_16sc_t* out, const
++ *out = accum_result[0] + accum_result[1] + accum_result[2] + accum_result[3];
++
++ // tail case
++- for(number = quarter_points * 4; number < num_points; ++number)
++- {
++- *out += (*a_ptr++) * (*b_ptr++);
++- }
+++ for (number = quarter_points * 4; number < num_points; ++number) {
+++ *out += (*a_ptr++) * (*b_ptr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_NEON */
++diff --git a/kernels/volk/volk_16ic_x2_multiply_16ic.h b/kernels/volk/volk_16ic_x2_multiply_16ic.h
++index 20d6a7f..2bf835d 100644
++--- a/kernels/volk/volk_16ic_x2_multiply_16ic.h
+++++ b/kernels/volk/volk_16ic_x2_multiply_16ic.h
++@@ -25,18 +25,19 @@
++ *
++ * \b Overview
++ *
++- * Multiplies two input complex vectors, point-by-point, storing the result in the third vector.
++- * WARNING: Saturation is not checked.
+++ * Multiplies two input complex vectors, point-by-point, storing the result in the third
+++ * vector. WARNING: Saturation is not checked.
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_16ic_x2_multiply_16ic(lv_16sc_t* result, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points);
++- * \endcode
+++ * void volk_16ic_x2_multiply_16ic(lv_16sc_t* result, const lv_16sc_t* in_a, const
+++ * lv_16sc_t* in_b, unsigned int num_points); \endcode
++ *
++ * \b Inputs
++ * \li in_a: One of the vectors to be multiplied.
++ * \li in_b: The other vector to be multiplied.
++- * \li num_points: The number of complex data points to be multiplied from both input vectors.
+++ * \li num_points: The number of complex data points to be multiplied from both input
+++ * vectors.
++ *
++ * \b Outputs
++ * \li result: The vector where the results will be stored.
++@@ -51,13 +52,15 @@
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_16ic_x2_multiply_16ic_generic(lv_16sc_t* result, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_multiply_16ic_generic(lv_16sc_t* result,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++ unsigned int n;
++- for (n = 0; n < num_points; n++)
++- {
++- result[n] = in_a[n] * in_b[n];
++- }
+++ for (n = 0; n < num_points; n++) {
+++ result[n] = in_a[n] * in_b[n];
+++ }
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -66,51 +69,58 @@ static inline void volk_16ic_x2_multiply_16ic_generic(lv_16sc_t* result, const l
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_16ic_x2_multiply_16ic_a_sse2(lv_16sc_t* out, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_multiply_16ic_a_sse2(lv_16sc_t* out,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++ const unsigned int sse_iters = num_points / 4;
++- __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl, result;
+++ __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl,
+++ result;
++
++- mask_imag = _mm_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
++- mask_real = _mm_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
+++ mask_imag = _mm_set_epi8(
+++ 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
+++ mask_real = _mm_set_epi8(
+++ 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
++
++ const lv_16sc_t* _in_a = in_a;
++ const lv_16sc_t* _in_b = in_b;
++ lv_16sc_t* _out = out;
++ unsigned int number;
++
++- for(number = 0; number < sse_iters; number++)
++- {
++- a = _mm_load_si128((__m128i*)_in_a); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
++- b = _mm_load_si128((__m128i*)_in_b);
++- c = _mm_mullo_epi16 (a, b); // a3.i*b3.i, a3.r*b3.r, ....
+++ for (number = 0; number < sse_iters; number++) {
+++ a = _mm_load_si128(
+++ (__m128i*)_in_a); // load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+++ b = _mm_load_si128((__m128i*)_in_b);
+++ c = _mm_mullo_epi16(a, b); // a3.i*b3.i, a3.r*b3.r, ....
++
++- c_sr = _mm_srli_si128 (c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
++- real = _mm_subs_epi16 (c, c_sr);
++- real = _mm_and_si128 (real, mask_real); // a3.r*b3.r-a3.i*b3.i , 0, a3.r*b3.r- a3.i*b3.i
+++ c_sr = _mm_srli_si128(c, 2); // Shift a right by imm8 bytes while shifting in
+++ // zeros, and store the results in dst.
+++ real = _mm_subs_epi16(c, c_sr);
+++ real = _mm_and_si128(real,
+++ mask_real); // a3.r*b3.r-a3.i*b3.i , 0, a3.r*b3.r- a3.i*b3.i
++
++- b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
++- a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
+++ b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
+++ a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
++
++- imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
++- imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+++ imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
+++ imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
++
++- imag = _mm_adds_epi16(imag1, imag2);
++- imag = _mm_and_si128 (imag, mask_imag); // a3.i*b3.r+b3.i*a3.r, 0, ...
+++ imag = _mm_adds_epi16(imag1, imag2);
+++ imag = _mm_and_si128(imag, mask_imag); // a3.i*b3.r+b3.i*a3.r, 0, ...
++
++- result = _mm_or_si128 (real, imag);
+++ result = _mm_or_si128(real, imag);
++
++- _mm_store_si128((__m128i*)_out, result);
+++ _mm_store_si128((__m128i*)_out, result);
++
++- _in_a += 4;
++- _in_b += 4;
++- _out += 4;
++- }
+++ _in_a += 4;
+++ _in_b += 4;
+++ _out += 4;
+++ }
++
++- for (number = sse_iters * 4; number < num_points; ++number)
++- {
++- *_out++ = (*_in_a++) * (*_in_b++);
++- }
+++ for (number = sse_iters * 4; number < num_points; ++number) {
+++ *_out++ = (*_in_a++) * (*_in_b++);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++@@ -118,51 +128,58 @@ static inline void volk_16ic_x2_multiply_16ic_a_sse2(lv_16sc_t* out, const lv_16
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_16ic_x2_multiply_16ic_u_sse2(lv_16sc_t* out, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_multiply_16ic_u_sse2(lv_16sc_t* out,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++ const unsigned int sse_iters = num_points / 4;
++- __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1,imag2, b_sl, a_sl, result;
+++ __m128i a, b, c, c_sr, mask_imag, mask_real, real, imag, imag1, imag2, b_sl, a_sl,
+++ result;
++
++- mask_imag = _mm_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
++- mask_real = _mm_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
+++ mask_imag = _mm_set_epi8(
+++ 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
+++ mask_real = _mm_set_epi8(
+++ 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
++
++ const lv_16sc_t* _in_a = in_a;
++ const lv_16sc_t* _in_b = in_b;
++ lv_16sc_t* _out = out;
++ unsigned int number;
++
++- for(number = 0; number < sse_iters; number++)
++- {
++- a = _mm_loadu_si128((__m128i*)_in_a); //load (2 byte imag, 2 byte real) x 4 into 128 bits reg
++- b = _mm_loadu_si128((__m128i*)_in_b);
++- c = _mm_mullo_epi16 (a, b); // a3.i*b3.i, a3.r*b3.r, ....
+++ for (number = 0; number < sse_iters; number++) {
+++ a = _mm_loadu_si128(
+++ (__m128i*)_in_a); // load (2 byte imag, 2 byte real) x 4 into 128 bits reg
+++ b = _mm_loadu_si128((__m128i*)_in_b);
+++ c = _mm_mullo_epi16(a, b); // a3.i*b3.i, a3.r*b3.r, ....
++
++- c_sr = _mm_srli_si128 (c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
++- real = _mm_subs_epi16 (c, c_sr);
++- real = _mm_and_si128 (real, mask_real); // a3.r*b3.r-a3.i*b3.i , 0, a3.r*b3.r- a3.i*b3.i
+++ c_sr = _mm_srli_si128(c, 2); // Shift a right by imm8 bytes while shifting in
+++ // zeros, and store the results in dst.
+++ real = _mm_subs_epi16(c, c_sr);
+++ real = _mm_and_si128(real,
+++ mask_real); // a3.r*b3.r-a3.i*b3.i , 0, a3.r*b3.r- a3.i*b3.i
++
++- b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
++- a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
+++ b_sl = _mm_slli_si128(b, 2); // b3.r, b2.i ....
+++ a_sl = _mm_slli_si128(a, 2); // a3.r, a2.i ....
++
++- imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
++- imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+++ imag1 = _mm_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
+++ imag2 = _mm_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
++
++- imag = _mm_adds_epi16(imag1, imag2);
++- imag = _mm_and_si128 (imag, mask_imag); // a3.i*b3.r+b3.i*a3.r, 0, ...
+++ imag = _mm_adds_epi16(imag1, imag2);
+++ imag = _mm_and_si128(imag, mask_imag); // a3.i*b3.r+b3.i*a3.r, 0, ...
++
++- result = _mm_or_si128 (real, imag);
+++ result = _mm_or_si128(real, imag);
++
++- _mm_storeu_si128((__m128i*)_out, result);
+++ _mm_storeu_si128((__m128i*)_out, result);
++
++- _in_a += 4;
++- _in_b += 4;
++- _out += 4;
++- }
+++ _in_a += 4;
+++ _in_b += 4;
+++ _out += 4;
+++ }
++
++- for (number = sse_iters * 4; number < num_points; ++number)
++- {
++- *_out++ = (*_in_a++) * (*_in_b++);
++- }
+++ for (number = sse_iters * 4; number < num_points; ++number) {
+++ *_out++ = (*_in_a++) * (*_in_b++);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++@@ -170,7 +187,10 @@ static inline void volk_16ic_x2_multiply_16ic_u_sse2(lv_16sc_t* out, const lv_16
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void volk_16ic_x2_multiply_16ic_u_avx2(lv_16sc_t* out, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_multiply_16ic_u_avx2(lv_16sc_t* out,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++ unsigned int number = 0;
++ const unsigned int avx2_points = num_points / 8;
++@@ -179,44 +199,108 @@ static inline void volk_16ic_x2_multiply_16ic_u_avx2(lv_16sc_t* out, const lv_16
++ const lv_16sc_t* _in_b = in_b;
++ lv_16sc_t* _out = out;
++
++- __m256i a, b, c, c_sr, real, imag, imag1, imag2, b_sl, a_sl, result;
++-
++- const __m256i mask_imag = _mm256_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
++- const __m256i mask_real = _mm256_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
++-
++- for(;number < avx2_points; number++)
++- {
++- a = _mm256_loadu_si256((__m256i*)_in_a); // Load the ar + ai, br + bi as ar,ai,br,bi
++- b = _mm256_loadu_si256((__m256i*)_in_b); // Load the cr + ci, dr + di as cr,ci,dr,di
++- c = _mm256_mullo_epi16(a, b);
++-
++- c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
++- real = _mm256_subs_epi16(c, c_sr);
++- real = _mm256_and_si256(real, mask_real); // a3.r*b3.r-a3.i*b3.i , 0, a3.r*b3.r- a3.i*b3.i
++-
++- b_sl = _mm256_slli_si256(b, 2); // b3.r, b2.i ....
++- a_sl = _mm256_slli_si256(a, 2); // a3.r, a2.i ....
++-
++- imag1 = _mm256_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
++- imag2 = _mm256_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
++-
++- imag = _mm256_adds_epi16(imag1, imag2);
++- imag = _mm256_and_si256(imag, mask_imag); // a3.i*b3.r+b3.i*a3.r, 0, ...
++-
++- result = _mm256_or_si256(real, imag);
++-
++- _mm256_storeu_si256((__m256i*)_out, result);
++-
++- _in_a += 8;
++- _in_b += 8;
++- _out += 8;
++- }
+++ __m256i a, b, c, c_sr, real, imag, imag1, imag2, b_sl, a_sl, result;
+++
+++ const __m256i mask_imag = _mm256_set_epi8(0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0);
+++ const __m256i mask_real = _mm256_set_epi8(0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF);
+++
+++ for (; number < avx2_points; number++) {
+++ a = _mm256_loadu_si256(
+++ (__m256i*)_in_a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ b = _mm256_loadu_si256(
+++ (__m256i*)_in_b); // Load the cr + ci, dr + di as cr,ci,dr,di
+++ c = _mm256_mullo_epi16(a, b);
+++
+++ c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting in
+++ // zeros, and store the results in dst.
+++ real = _mm256_subs_epi16(c, c_sr);
+++ real = _mm256_and_si256(
+++ real, mask_real); // a3.r*b3.r-a3.i*b3.i , 0, a3.r*b3.r- a3.i*b3.i
+++
+++ b_sl = _mm256_slli_si256(b, 2); // b3.r, b2.i ....
+++ a_sl = _mm256_slli_si256(a, 2); // a3.r, a2.i ....
+++
+++ imag1 = _mm256_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
+++ imag2 = _mm256_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+++
+++ imag = _mm256_adds_epi16(imag1, imag2);
+++ imag = _mm256_and_si256(imag, mask_imag); // a3.i*b3.r+b3.i*a3.r, 0, ...
+++
+++ result = _mm256_or_si256(real, imag);
+++
+++ _mm256_storeu_si256((__m256i*)_out, result);
+++
+++ _in_a += 8;
+++ _in_b += 8;
+++ _out += 8;
+++ }
++ _mm256_zeroupper();
++ number = avx2_points * 8;
++- for(;number < num_points; number++)
++- {
++- *_out++ = (*_in_a++) * (*_in_b++);
++- }
+++ for (; number < num_points; number++) {
+++ *_out++ = (*_in_a++) * (*_in_b++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -224,7 +308,10 @@ static inline void volk_16ic_x2_multiply_16ic_u_avx2(lv_16sc_t* out, const lv_16
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void volk_16ic_x2_multiply_16ic_a_avx2(lv_16sc_t* out, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_multiply_16ic_a_avx2(lv_16sc_t* out,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++ unsigned int number = 0;
++ const unsigned int avx2_points = num_points / 8;
++@@ -233,44 +320,108 @@ static inline void volk_16ic_x2_multiply_16ic_a_avx2(lv_16sc_t* out, const lv_16
++ const lv_16sc_t* _in_b = in_b;
++ lv_16sc_t* _out = out;
++
++- __m256i a, b, c, c_sr, real, imag, imag1, imag2, b_sl, a_sl, result;
++-
++- const __m256i mask_imag = _mm256_set_epi8(0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0);
++- const __m256i mask_real = _mm256_set_epi8(0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF, 0, 0, 0xFF, 0xFF);
++-
++- for(;number < avx2_points; number++)
++- {
++- a = _mm256_load_si256((__m256i*)_in_a); // Load the ar + ai, br + bi as ar,ai,br,bi
++- b = _mm256_load_si256((__m256i*)_in_b); // Load the cr + ci, dr + di as cr,ci,dr,di
++- c = _mm256_mullo_epi16(a, b);
++-
++- c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting in zeros, and store the results in dst.
++- real = _mm256_subs_epi16(c, c_sr);
++- real = _mm256_and_si256(real, mask_real); // a3.r*b3.r-a3.i*b3.i , 0, a3.r*b3.r- a3.i*b3.i
++-
++- b_sl = _mm256_slli_si256(b, 2); // b3.r, b2.i ....
++- a_sl = _mm256_slli_si256(a, 2); // a3.r, a2.i ....
++-
++- imag1 = _mm256_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
++- imag2 = _mm256_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
++-
++- imag = _mm256_adds_epi16(imag1, imag2);
++- imag = _mm256_and_si256(imag, mask_imag); // a3.i*b3.r+b3.i*a3.r, 0, ...
++-
++- result = _mm256_or_si256(real, imag);
++-
++- _mm256_store_si256((__m256i*)_out, result);
++-
++- _in_a += 8;
++- _in_b += 8;
++- _out += 8;
++- }
+++ __m256i a, b, c, c_sr, real, imag, imag1, imag2, b_sl, a_sl, result;
+++
+++ const __m256i mask_imag = _mm256_set_epi8(0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0);
+++ const __m256i mask_real = _mm256_set_epi8(0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF,
+++ 0,
+++ 0,
+++ 0xFF,
+++ 0xFF);
+++
+++ for (; number < avx2_points; number++) {
+++ a = _mm256_load_si256(
+++ (__m256i*)_in_a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ b = _mm256_load_si256(
+++ (__m256i*)_in_b); // Load the cr + ci, dr + di as cr,ci,dr,di
+++ c = _mm256_mullo_epi16(a, b);
+++
+++ c_sr = _mm256_srli_si256(c, 2); // Shift a right by imm8 bytes while shifting in
+++ // zeros, and store the results in dst.
+++ real = _mm256_subs_epi16(c, c_sr);
+++ real = _mm256_and_si256(
+++ real, mask_real); // a3.r*b3.r-a3.i*b3.i , 0, a3.r*b3.r- a3.i*b3.i
+++
+++ b_sl = _mm256_slli_si256(b, 2); // b3.r, b2.i ....
+++ a_sl = _mm256_slli_si256(a, 2); // a3.r, a2.i ....
+++
+++ imag1 = _mm256_mullo_epi16(a, b_sl); // a3.i*b3.r, ....
+++ imag2 = _mm256_mullo_epi16(b, a_sl); // b3.i*a3.r, ....
+++
+++ imag = _mm256_adds_epi16(imag1, imag2);
+++ imag = _mm256_and_si256(imag, mask_imag); // a3.i*b3.r+b3.i*a3.r, 0, ...
+++
+++ result = _mm256_or_si256(real, imag);
+++
+++ _mm256_store_si256((__m256i*)_out, result);
+++
+++ _in_a += 8;
+++ _in_b += 8;
+++ _out += 8;
+++ }
++ _mm256_zeroupper();
++ number = avx2_points * 8;
++- for(;number < num_points; number++)
++- {
++- *_out++ = (*_in_a++) * (*_in_b++);
++- }
+++ for (; number < num_points; number++) {
+++ *_out++ = (*_in_a++) * (*_in_b++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -278,48 +429,49 @@ static inline void volk_16ic_x2_multiply_16ic_a_avx2(lv_16sc_t* out, const lv_16
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_16ic_x2_multiply_16ic_neon(lv_16sc_t* out, const lv_16sc_t* in_a, const lv_16sc_t* in_b, unsigned int num_points)
+++static inline void volk_16ic_x2_multiply_16ic_neon(lv_16sc_t* out,
+++ const lv_16sc_t* in_a,
+++ const lv_16sc_t* in_b,
+++ unsigned int num_points)
++ {
++- lv_16sc_t *a_ptr = (lv_16sc_t*) in_a;
++- lv_16sc_t *b_ptr = (lv_16sc_t*) in_b;
+++ lv_16sc_t* a_ptr = (lv_16sc_t*)in_a;
+++ lv_16sc_t* b_ptr = (lv_16sc_t*)in_b;
++ unsigned int quarter_points = num_points / 4;
++ int16x4x2_t a_val, b_val, c_val;
++ int16x4x2_t tmp_real, tmp_imag;
++ unsigned int number = 0;
++
++- for(number = 0; number < quarter_points; ++number)
++- {
++- a_val = vld2_s16((int16_t*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
++- b_val = vld2_s16((int16_t*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
++- __VOLK_PREFETCH(a_ptr + 4);
++- __VOLK_PREFETCH(b_ptr + 4);
++-
++- // multiply the real*real and imag*imag to get real result
++- // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
++- tmp_real.val[0] = vmul_s16(a_val.val[0], b_val.val[0]);
++- // a0i*b0i|a1i*b1i|a2i*b2i|a3i*b3i
++- tmp_real.val[1] = vmul_s16(a_val.val[1], b_val.val[1]);
++-
++- // Multiply cross terms to get the imaginary result
++- // a0r*b0i|a1r*b1i|a2r*b2i|a3r*b3i
++- tmp_imag.val[0] = vmul_s16(a_val.val[0], b_val.val[1]);
++- // a0i*b0r|a1i*b1r|a2i*b2r|a3i*b3r
++- tmp_imag.val[1] = vmul_s16(a_val.val[1], b_val.val[0]);
++-
++- // store the results
++- c_val.val[0] = vsub_s16(tmp_real.val[0], tmp_real.val[1]);
++- c_val.val[1] = vadd_s16(tmp_imag.val[0], tmp_imag.val[1]);
++- vst2_s16((int16_t*)out, c_val);
++-
++- a_ptr += 4;
++- b_ptr += 4;
++- out += 4;
++- }
++-
++- for(number = quarter_points * 4; number < num_points; number++)
++- {
++- *out++ = (*a_ptr++) * (*b_ptr++);
++- }
+++ for (number = 0; number < quarter_points; ++number) {
+++ a_val = vld2_s16((int16_t*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
+++ b_val = vld2_s16((int16_t*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
+++ __VOLK_PREFETCH(a_ptr + 4);
+++ __VOLK_PREFETCH(b_ptr + 4);
+++
+++ // multiply the real*real and imag*imag to get real result
+++ // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
+++ tmp_real.val[0] = vmul_s16(a_val.val[0], b_val.val[0]);
+++ // a0i*b0i|a1i*b1i|a2i*b2i|a3i*b3i
+++ tmp_real.val[1] = vmul_s16(a_val.val[1], b_val.val[1]);
+++
+++ // Multiply cross terms to get the imaginary result
+++ // a0r*b0i|a1r*b1i|a2r*b2i|a3r*b3i
+++ tmp_imag.val[0] = vmul_s16(a_val.val[0], b_val.val[1]);
+++ // a0i*b0r|a1i*b1r|a2i*b2r|a3i*b3r
+++ tmp_imag.val[1] = vmul_s16(a_val.val[1], b_val.val[0]);
+++
+++ // store the results
+++ c_val.val[0] = vsub_s16(tmp_real.val[0], tmp_real.val[1]);
+++ c_val.val[1] = vadd_s16(tmp_imag.val[0], tmp_imag.val[1]);
+++ vst2_s16((int16_t*)out, c_val);
+++
+++ a_ptr += 4;
+++ b_ptr += 4;
+++ out += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ *out++ = (*a_ptr++) * (*b_ptr++);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++diff --git a/kernels/volk/volk_16u_byteswap.h b/kernels/volk/volk_16u_byteswap.h
++index eaa972f..221dcdb 100644
++--- a/kernels/volk/volk_16u_byteswap.h
+++++ b/kernels/volk/volk_16u_byteswap.h
++@@ -58,74 +58,80 @@
++
++ #if LV_HAVE_AVX2
++ #include <immintrin.h>
++-static inline void volk_16u_byteswap_a_avx2(uint16_t* intsToSwap, unsigned int num_points){
++- unsigned int number;
+++static inline void volk_16u_byteswap_a_avx2(uint16_t* intsToSwap, unsigned int num_points)
+++{
+++ unsigned int number;
++
++- const unsigned int nPerSet = 16;
++- const uint64_t nSets = num_points / nPerSet;
+++ const unsigned int nPerSet = 16;
+++ const uint64_t nSets = num_points / nPerSet;
++
++- uint16_t* inputPtr = (uint16_t*) intsToSwap;
+++ uint16_t* inputPtr = (uint16_t*)intsToSwap;
++
++- const uint8_t shuffleVector[32] = { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14, 17, 16, 19, 18, 21, 20, 23, 22, 25, 24, 27, 26, 29, 28, 31, 30};
+++ const uint8_t shuffleVector[32] = { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11,
+++ 10, 13, 12, 15, 14, 17, 16, 19, 18, 21, 20,
+++ 23, 22, 25, 24, 27, 26, 29, 28, 31, 30 };
++
++- const __m256i myShuffle = _mm256_loadu_si256((__m256i*) &shuffleVector[0]);
+++ const __m256i myShuffle = _mm256_loadu_si256((__m256i*)&shuffleVector[0]);
++
++- for(number = 0; number < nSets; number++) {
++- // Load the 32t values, increment inputPtr later since we're doing it in-place.
++- const __m256i input = _mm256_load_si256((__m256i*)inputPtr);
++- const __m256i output = _mm256_shuffle_epi8(input, myShuffle);
+++ for (number = 0; number < nSets; number++) {
+++ // Load the 32t values, increment inputPtr later since we're doing it in-place.
+++ const __m256i input = _mm256_load_si256((__m256i*)inputPtr);
+++ const __m256i output = _mm256_shuffle_epi8(input, myShuffle);
++
++- // Store the results
++- _mm256_store_si256((__m256i*)inputPtr, output);
++- inputPtr += nPerSet;
++- }
+++ // Store the results
+++ _mm256_store_si256((__m256i*)inputPtr, output);
+++ inputPtr += nPerSet;
+++ }
++
++- _mm256_zeroupper();
+++ _mm256_zeroupper();
++
++- // Byteswap any remaining points:
++- for(number = nPerSet * nSets; number < num_points; number++) {
++- uint16_t outputVal = *inputPtr;
++- outputVal = (((outputVal >> 8) & 0xff) | ((outputVal << 8) & 0xff00));
++- *inputPtr = outputVal;
++- inputPtr++;
++- }
+++ // Byteswap any remaining points:
+++ for (number = nPerSet * nSets; number < num_points; number++) {
+++ uint16_t outputVal = *inputPtr;
+++ outputVal = (((outputVal >> 8) & 0xff) | ((outputVal << 8) & 0xff00));
+++ *inputPtr = outputVal;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++
++ #if LV_HAVE_AVX2
++ #include <immintrin.h>
++-static inline void volk_16u_byteswap_u_avx2(uint16_t* intsToSwap, unsigned int num_points){
++- unsigned int number;
+++static inline void volk_16u_byteswap_u_avx2(uint16_t* intsToSwap, unsigned int num_points)
+++{
+++ unsigned int number;
++
++- const unsigned int nPerSet = 16;
++- const uint64_t nSets = num_points / nPerSet;
+++ const unsigned int nPerSet = 16;
+++ const uint64_t nSets = num_points / nPerSet;
++
++- uint16_t* inputPtr = (uint16_t*) intsToSwap;
+++ uint16_t* inputPtr = (uint16_t*)intsToSwap;
++
++- const uint8_t shuffleVector[32] = { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14, 17, 16, 19, 18, 21, 20, 23, 22, 25, 24, 27, 26, 29, 28, 31, 30};
+++ const uint8_t shuffleVector[32] = { 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11,
+++ 10, 13, 12, 15, 14, 17, 16, 19, 18, 21, 20,
+++ 23, 22, 25, 24, 27, 26, 29, 28, 31, 30 };
++
++- const __m256i myShuffle = _mm256_loadu_si256((__m256i*) &shuffleVector[0]);
+++ const __m256i myShuffle = _mm256_loadu_si256((__m256i*)&shuffleVector[0]);
++
++- for (number = 0; number < nSets; number++) {
++- // Load the 32t values, increment inputPtr later since we're doing it in-place.
++- const __m256i input = _mm256_loadu_si256((__m256i*)inputPtr);
++- const __m256i output = _mm256_shuffle_epi8(input,myShuffle);
+++ for (number = 0; number < nSets; number++) {
+++ // Load the 32t values, increment inputPtr later since we're doing it in-place.
+++ const __m256i input = _mm256_loadu_si256((__m256i*)inputPtr);
+++ const __m256i output = _mm256_shuffle_epi8(input, myShuffle);
++
++- // Store the results
++- _mm256_storeu_si256((__m256i*)inputPtr, output);
++- inputPtr += nPerSet;
++- }
+++ // Store the results
+++ _mm256_storeu_si256((__m256i*)inputPtr, output);
+++ inputPtr += nPerSet;
+++ }
++
++- _mm256_zeroupper();
+++ _mm256_zeroupper();
++
++- // Byteswap any remaining points:
++- for(number = nPerSet * nSets; number < num_points; number++) {
++- uint16_t outputVal = *inputPtr;
++- outputVal = (((outputVal >> 8) & 0xff) | ((outputVal << 8) & 0xff00));
++- *inputPtr = outputVal;
++- inputPtr++;
++- }
+++ // Byteswap any remaining points:
+++ for (number = nPerSet * nSets; number < num_points; number++) {
+++ uint16_t outputVal = *inputPtr;
+++ outputVal = (((outputVal >> 8) & 0xff) | ((outputVal << 8) & 0xff00));
+++ *inputPtr = outputVal;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -133,47 +139,50 @@ static inline void volk_16u_byteswap_u_avx2(uint16_t* intsToSwap, unsigned int n
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_16u_byteswap_u_sse2(uint16_t* intsToSwap, unsigned int num_points){
++- unsigned int number = 0;
++- uint16_t* inputPtr = intsToSwap;
++- __m128i input, left, right, output;
++-
++- const unsigned int eighthPoints = num_points / 8;
++- for(;number < eighthPoints; number++){
++- // Load the 16t values, increment inputPtr later since we're doing it in-place.
++- input = _mm_loadu_si128((__m128i*)inputPtr);
++- // Do the two shifts
++- left = _mm_slli_epi16(input, 8);
++- right = _mm_srli_epi16(input, 8);
++- // Or the left and right halves together
++- output = _mm_or_si128(left, right);
++- // Store the results
++- _mm_storeu_si128((__m128i*)inputPtr, output);
++- inputPtr += 8;
++- }
++-
++- // Byteswap any remaining points:
++- number = eighthPoints*8;
++- for(; number < num_points; number++){
++- uint16_t outputVal = *inputPtr;
++- outputVal = (((outputVal >> 8) & 0xff) | ((outputVal << 8) & 0xff00));
++- *inputPtr = outputVal;
++- inputPtr++;
++- }
+++static inline void volk_16u_byteswap_u_sse2(uint16_t* intsToSwap, unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ uint16_t* inputPtr = intsToSwap;
+++ __m128i input, left, right, output;
+++
+++ const unsigned int eighthPoints = num_points / 8;
+++ for (; number < eighthPoints; number++) {
+++ // Load the 16t values, increment inputPtr later since we're doing it in-place.
+++ input = _mm_loadu_si128((__m128i*)inputPtr);
+++ // Do the two shifts
+++ left = _mm_slli_epi16(input, 8);
+++ right = _mm_srli_epi16(input, 8);
+++ // Or the left and right halves together
+++ output = _mm_or_si128(left, right);
+++ // Store the results
+++ _mm_storeu_si128((__m128i*)inputPtr, output);
+++ inputPtr += 8;
+++ }
+++
+++ // Byteswap any remaining points:
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ uint16_t outputVal = *inputPtr;
+++ outputVal = (((outputVal >> 8) & 0xff) | ((outputVal << 8) & 0xff00));
+++ *inputPtr = outputVal;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_16u_byteswap_generic(uint16_t* intsToSwap, unsigned int num_points){
++- unsigned int point;
++- uint16_t* inputPtr = intsToSwap;
++- for(point = 0; point < num_points; point++){
++- uint16_t output = *inputPtr;
++- output = (((output >> 8) & 0xff) | ((output << 8) & 0xff00));
++- *inputPtr = output;
++- inputPtr++;
++- }
+++static inline void volk_16u_byteswap_generic(uint16_t* intsToSwap,
+++ unsigned int num_points)
+++{
+++ unsigned int point;
+++ uint16_t* inputPtr = intsToSwap;
+++ for (point = 0; point < num_points; point++) {
+++ uint16_t output = *inputPtr;
+++ output = (((output >> 8) & 0xff) | ((output << 8) & 0xff00));
+++ *inputPtr = output;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -187,129 +196,136 @@ static inline void volk_16u_byteswap_generic(uint16_t* intsToSwap, unsigned int
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_16u_byteswap_a_sse2(uint16_t* intsToSwap, unsigned int num_points){
++- unsigned int number = 0;
++- uint16_t* inputPtr = intsToSwap;
++- __m128i input, left, right, output;
++-
++- const unsigned int eighthPoints = num_points / 8;
++- for(;number < eighthPoints; number++){
++- // Load the 16t values, increment inputPtr later since we're doing it in-place.
++- input = _mm_load_si128((__m128i*)inputPtr);
++- // Do the two shifts
++- left = _mm_slli_epi16(input, 8);
++- right = _mm_srli_epi16(input, 8);
++- // Or the left and right halves together
++- output = _mm_or_si128(left, right);
++- // Store the results
++- _mm_store_si128((__m128i*)inputPtr, output);
++- inputPtr += 8;
++- }
++-
++-
++- // Byteswap any remaining points:
++- number = eighthPoints*8;
++- for(; number < num_points; number++){
++- uint16_t outputVal = *inputPtr;
++- outputVal = (((outputVal >> 8) & 0xff) | ((outputVal << 8) & 0xff00));
++- *inputPtr = outputVal;
++- inputPtr++;
++- }
+++static inline void volk_16u_byteswap_a_sse2(uint16_t* intsToSwap, unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ uint16_t* inputPtr = intsToSwap;
+++ __m128i input, left, right, output;
+++
+++ const unsigned int eighthPoints = num_points / 8;
+++ for (; number < eighthPoints; number++) {
+++ // Load the 16t values, increment inputPtr later since we're doing it in-place.
+++ input = _mm_load_si128((__m128i*)inputPtr);
+++ // Do the two shifts
+++ left = _mm_slli_epi16(input, 8);
+++ right = _mm_srli_epi16(input, 8);
+++ // Or the left and right halves together
+++ output = _mm_or_si128(left, right);
+++ // Store the results
+++ _mm_store_si128((__m128i*)inputPtr, output);
+++ inputPtr += 8;
+++ }
+++
+++
+++ // Byteswap any remaining points:
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ uint16_t outputVal = *inputPtr;
+++ outputVal = (((outputVal >> 8) & 0xff) | ((outputVal << 8) & 0xff00));
+++ *inputPtr = outputVal;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_16u_byteswap_neon(uint16_t* intsToSwap, unsigned int num_points){
++- unsigned int number;
++- unsigned int eighth_points = num_points / 8;
++- uint16x8_t input, output;
++- uint16_t* inputPtr = intsToSwap;
++-
++- for(number = 0; number < eighth_points; number++) {
++- input = vld1q_u16(inputPtr);
++- output = vsriq_n_u16(output, input, 8);
++- output = vsliq_n_u16(output, input, 8);
++- vst1q_u16(inputPtr, output);
++- inputPtr += 8;
++- }
++-
++- for(number = eighth_points * 8; number < num_points; number++){
++- uint16_t output = *inputPtr;
++- output = (((output >> 8) & 0xff) | ((output << 8) & 0xff00));
++- *inputPtr = output;
++- inputPtr++;
++- }
+++static inline void volk_16u_byteswap_neon(uint16_t* intsToSwap, unsigned int num_points)
+++{
+++ unsigned int number;
+++ unsigned int eighth_points = num_points / 8;
+++ uint16x8_t input, output;
+++ uint16_t* inputPtr = intsToSwap;
+++
+++ for (number = 0; number < eighth_points; number++) {
+++ input = vld1q_u16(inputPtr);
+++ output = vsriq_n_u16(output, input, 8);
+++ output = vsliq_n_u16(output, input, 8);
+++ vst1q_u16(inputPtr, output);
+++ inputPtr += 8;
+++ }
+++
+++ for (number = eighth_points * 8; number < num_points; number++) {
+++ uint16_t output = *inputPtr;
+++ output = (((output >> 8) & 0xff) | ((output << 8) & 0xff00));
+++ *inputPtr = output;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_16u_byteswap_neon_table(uint16_t* intsToSwap, unsigned int num_points){
++- uint16_t* inputPtr = intsToSwap;
++- unsigned int number = 0;
++- unsigned int n16points = num_points / 16;
++-
++- uint8x8x4_t input_table;
++- uint8x8_t int_lookup01, int_lookup23, int_lookup45, int_lookup67;
++- uint8x8_t swapped_int01, swapped_int23, swapped_int45, swapped_int67;
++-
++- /* these magic numbers are used as byte-indices in the LUT.
++- they are pre-computed to save time. A simple C program
++- can calculate them; for example for lookup01:
++- uint8_t chars[8] = {24, 16, 8, 0, 25, 17, 9, 1};
++- for(ii=0; ii < 8; ++ii) {
++- index += ((uint64_t)(*(chars+ii))) << (ii*8);
+++static inline void volk_16u_byteswap_neon_table(uint16_t* intsToSwap,
+++ unsigned int num_points)
+++{
+++ uint16_t* inputPtr = intsToSwap;
+++ unsigned int number = 0;
+++ unsigned int n16points = num_points / 16;
+++
+++ uint8x8x4_t input_table;
+++ uint8x8_t int_lookup01, int_lookup23, int_lookup45, int_lookup67;
+++ uint8x8_t swapped_int01, swapped_int23, swapped_int45, swapped_int67;
+++
+++ /* these magic numbers are used as byte-indices in the LUT.
+++ they are pre-computed to save time. A simple C program
+++ can calculate them; for example for lookup01:
+++ uint8_t chars[8] = {24, 16, 8, 0, 25, 17, 9, 1};
+++ for(ii=0; ii < 8; ++ii) {
+++ index += ((uint64_t)(*(chars+ii))) << (ii*8);
+++ }
+++ */
+++ int_lookup01 = vcreate_u8(1232017111498883080);
+++ int_lookup23 = vcreate_u8(1376697457175036426);
+++ int_lookup45 = vcreate_u8(1521377802851189772);
+++ int_lookup67 = vcreate_u8(1666058148527343118);
+++
+++ for (number = 0; number < n16points; ++number) {
+++ input_table = vld4_u8((uint8_t*)inputPtr);
+++ swapped_int01 = vtbl4_u8(input_table, int_lookup01);
+++ swapped_int23 = vtbl4_u8(input_table, int_lookup23);
+++ swapped_int45 = vtbl4_u8(input_table, int_lookup45);
+++ swapped_int67 = vtbl4_u8(input_table, int_lookup67);
+++ vst1_u8((uint8_t*)inputPtr, swapped_int01);
+++ vst1_u8((uint8_t*)(inputPtr + 4), swapped_int23);
+++ vst1_u8((uint8_t*)(inputPtr + 8), swapped_int45);
+++ vst1_u8((uint8_t*)(inputPtr + 12), swapped_int67);
+++
+++ inputPtr += 16;
+++ }
+++
+++ for (number = n16points * 16; number < num_points; ++number) {
+++ uint16_t output = *inputPtr;
+++ output = (((output >> 8) & 0xff) | ((output << 8) & 0xff00));
+++ *inputPtr = output;
+++ inputPtr++;
++ }
++- */
++- int_lookup01 = vcreate_u8(1232017111498883080);
++- int_lookup23 = vcreate_u8(1376697457175036426);
++- int_lookup45 = vcreate_u8(1521377802851189772);
++- int_lookup67 = vcreate_u8(1666058148527343118);
++-
++- for(number = 0; number < n16points; ++number){
++- input_table = vld4_u8((uint8_t*) inputPtr);
++- swapped_int01 = vtbl4_u8(input_table, int_lookup01);
++- swapped_int23 = vtbl4_u8(input_table, int_lookup23);
++- swapped_int45 = vtbl4_u8(input_table, int_lookup45);
++- swapped_int67 = vtbl4_u8(input_table, int_lookup67);
++- vst1_u8((uint8_t*)inputPtr, swapped_int01);
++- vst1_u8((uint8_t*)(inputPtr+4), swapped_int23);
++- vst1_u8((uint8_t*)(inputPtr+8), swapped_int45);
++- vst1_u8((uint8_t*)(inputPtr+12), swapped_int67);
++-
++- inputPtr += 16;
++- }
++-
++- for(number = n16points * 16; number < num_points; ++number){
++- uint16_t output = *inputPtr;
++- output = (((output >> 8) & 0xff) | ((output << 8) & 0xff00));
++- *inputPtr = output;
++- inputPtr++;
++- }
++ }
++ #endif /* LV_HAVE_NEON */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_16u_byteswap_a_generic(uint16_t* intsToSwap, unsigned int num_points){
++- unsigned int point;
++- uint16_t* inputPtr = intsToSwap;
++- for(point = 0; point < num_points; point++){
++- uint16_t output = *inputPtr;
++- output = (((output >> 8) & 0xff) | ((output << 8) & 0xff00));
++- *inputPtr = output;
++- inputPtr++;
++- }
+++static inline void volk_16u_byteswap_a_generic(uint16_t* intsToSwap,
+++ unsigned int num_points)
+++{
+++ unsigned int point;
+++ uint16_t* inputPtr = intsToSwap;
+++ for (point = 0; point < num_points; point++) {
+++ uint16_t output = *inputPtr;
+++ output = (((output >> 8) & 0xff) | ((output << 8) & 0xff00));
+++ *inputPtr = output;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_ORC
++
++ extern void volk_16u_byteswap_a_orc_impl(uint16_t* intsToSwap, unsigned int num_points);
++-static inline void volk_16u_byteswap_u_orc(uint16_t* intsToSwap, unsigned int num_points){
+++static inline void volk_16u_byteswap_u_orc(uint16_t* intsToSwap, unsigned int num_points)
+++{
++ volk_16u_byteswap_a_orc_impl(intsToSwap, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++diff --git a/kernels/volk/volk_16u_byteswappuppet_16u.h b/kernels/volk/volk_16u_byteswappuppet_16u.h
++index d3c8c5d..8cb1318 100644
++--- a/kernels/volk/volk_16u_byteswappuppet_16u.h
+++++ b/kernels/volk/volk_16u_byteswappuppet_16u.h
++@@ -3,69 +3,83 @@
++
++
++ #include <stdint.h>
++-#include <volk/volk_16u_byteswap.h>
++ #include <string.h>
+++#include <volk/volk_16u_byteswap.h>
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void volk_16u_byteswappuppet_16u_generic(uint16_t*output, uint16_t* intsToSwap, unsigned int num_points){
+++static inline void volk_16u_byteswappuppet_16u_generic(uint16_t* output,
+++ uint16_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_16u_byteswap_generic((uint16_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint16_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_NEON
++-static inline void volk_16u_byteswappuppet_16u_neon(uint16_t*output, uint16_t* intsToSwap, unsigned int num_points){
+++static inline void volk_16u_byteswappuppet_16u_neon(uint16_t* output,
+++ uint16_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_16u_byteswap_neon((uint16_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint16_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_NEON
++-static inline void volk_16u_byteswappuppet_16u_neon_table(uint16_t*output, uint16_t* intsToSwap, unsigned int num_points){
+++static inline void volk_16u_byteswappuppet_16u_neon_table(uint16_t* output,
+++ uint16_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_16u_byteswap_neon_table((uint16_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint16_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_SSE2
++-static inline void volk_16u_byteswappuppet_16u_u_sse2(uint16_t *output, uint16_t* intsToSwap, unsigned int num_points){
+++static inline void volk_16u_byteswappuppet_16u_u_sse2(uint16_t* output,
+++ uint16_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_16u_byteswap_u_sse2((uint16_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint16_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_SSE2
++-static inline void volk_16u_byteswappuppet_16u_a_sse2(uint16_t *output, uint16_t* intsToSwap, unsigned int num_points){
+++static inline void volk_16u_byteswappuppet_16u_a_sse2(uint16_t* output,
+++ uint16_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_16u_byteswap_a_sse2((uint16_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint16_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_AVX2
++-static inline void volk_16u_byteswappuppet_16u_u_avx2(uint16_t *output, uint16_t* intsToSwap, unsigned int num_points){
+++static inline void volk_16u_byteswappuppet_16u_u_avx2(uint16_t* output,
+++ uint16_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_16u_byteswap_u_avx2((uint16_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint16_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_AVX2
++-static inline void volk_16u_byteswappuppet_16u_a_avx2(uint16_t *output, uint16_t* intsToSwap, unsigned int num_points){
+++static inline void volk_16u_byteswappuppet_16u_a_avx2(uint16_t* output,
+++ uint16_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_16u_byteswap_a_avx2((uint16_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint16_t));
++-
++ }
++ #endif
++
++diff --git a/kernels/volk/volk_32f_64f_add_64f.h b/kernels/volk/volk_32f_64f_add_64f.h
++index 770c27e..d00ada5 100644
++--- a/kernels/volk/volk_32f_64f_add_64f.h
+++++ b/kernels/volk/volk_32f_64f_add_64f.h
++@@ -77,18 +77,19 @@
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32f_64f_add_64f_generic(double *cVector,
++- const float *aVector,
++- const double *bVector,
++- unsigned int num_points) {
++- double *cPtr = cVector;
++- const float *aPtr = aVector;
++- const double *bPtr = bVector;
++- unsigned int number = 0;
++-
++- for (number = 0; number < num_points; number++) {
++- *cPtr++ = ((double)(*aPtr++)) + (*bPtr++);
++- }
+++static inline void volk_32f_64f_add_64f_generic(double* cVector,
+++ const float* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
+++{
+++ double* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const double* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = ((double)(*aPtr++)) + (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -96,42 +97,43 @@ static inline void volk_32f_64f_add_64f_generic(double *cVector,
++ #ifdef LV_HAVE_NEONV8
++ #include <arm_neon.h>
++
++-static inline void volk_32f_64f_add_64f_neon(double *cVector,
++- const float *aVector,
++- const double *bVector,
++- unsigned int num_points) {
++- unsigned int number = 0;
++- const unsigned int half_points = num_points / 2;
++-
++- double *cPtr = cVector;
++- const float *aPtr = aVector;
++- const double *bPtr = bVector;
++-
++- float64x2_t aVal, bVal, cVal;
++- float32x2_t aVal1;
++- for (number = 0; number < half_points; number++) {
++- // Load in to NEON registers
++- aVal1 = vld1_f32(aPtr);
++- bVal = vld1q_f64(bPtr);
++- __VOLK_PREFETCH(aPtr + 2);
++- __VOLK_PREFETCH(bPtr + 2);
++- aPtr += 2; // q uses quadwords, 4 floats per vadd
++- bPtr += 2;
++-
++- // Vector conversion
++- aVal = vcvt_f64_f32(aVal1);
++- // vector add
++- cVal = vaddq_f64(aVal, bVal);
++- // Store the results back into the C container
++- vst1q_f64(cPtr, cVal);
++-
++- cPtr += 2;
++- }
++-
++- number = half_points * 2; // should be = num_points
++- for (; number < num_points; number++) {
++- *cPtr++ = ((double)(*aPtr++)) + (*bPtr++);
++- }
+++static inline void volk_32f_64f_add_64f_neon(double* cVector,
+++ const float* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const unsigned int half_points = num_points / 2;
+++
+++ double* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const double* bPtr = bVector;
+++
+++ float64x2_t aVal, bVal, cVal;
+++ float32x2_t aVal1;
+++ for (number = 0; number < half_points; number++) {
+++ // Load in to NEON registers
+++ aVal1 = vld1_f32(aPtr);
+++ bVal = vld1q_f64(bPtr);
+++ __VOLK_PREFETCH(aPtr + 2);
+++ __VOLK_PREFETCH(bPtr + 2);
+++ aPtr += 2; // q uses quadwords, 4 floats per vadd
+++ bPtr += 2;
+++
+++ // Vector conversion
+++ aVal = vcvt_f64_f32(aVal1);
+++ // vector add
+++ cVal = vaddq_f64(aVal, bVal);
+++ // Store the results back into the C container
+++ vst1q_f64(cPtr, cVal);
+++
+++ cPtr += 2;
+++ }
+++
+++ number = half_points * 2; // should be = num_points
+++ for (; number < num_points; number++) {
+++ *cPtr++ = ((double)(*aPtr++)) + (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_NEONV8 */
++@@ -141,49 +143,50 @@ static inline void volk_32f_64f_add_64f_neon(double *cVector,
++ #include <immintrin.h>
++ #include <xmmintrin.h>
++
++-static inline void volk_32f_64f_add_64f_u_avx(double *cVector,
++- const float *aVector,
++- const double *bVector,
++- unsigned int num_points) {
++- unsigned int number = 0;
++- const unsigned int eighth_points = num_points / 8;
++-
++- double *cPtr = cVector;
++- const float *aPtr = aVector;
++- const double *bPtr = bVector;
++-
++- __m256 aVal;
++- __m128 aVal1, aVal2;
++- __m256d aDbl1, aDbl2, bVal1, bVal2, cVal1, cVal2;
++- for (; number < eighth_points; number++) {
++-
++- aVal = _mm256_loadu_ps(aPtr);
++- bVal1 = _mm256_loadu_pd(bPtr);
++- bVal2 = _mm256_loadu_pd(bPtr + 4);
++-
++- aVal1 = _mm256_extractf128_ps(aVal, 0);
++- aVal2 = _mm256_extractf128_ps(aVal, 1);
++-
++- aDbl1 = _mm256_cvtps_pd(aVal1);
++- aDbl2 = _mm256_cvtps_pd(aVal2);
++-
++- cVal1 = _mm256_add_pd(aDbl1, bVal1);
++- cVal2 = _mm256_add_pd(aDbl2, bVal2);
++-
++- _mm256_storeu_pd(cPtr,
++- cVal1); // Store the results back into the C container
++- _mm256_storeu_pd(cPtr + 4,
++- cVal2); // Store the results back into the C container
++-
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
++-
++- number = eighth_points * 8;
++- for (; number < num_points; number++) {
++- *cPtr++ = ((double)(*aPtr++)) + (*bPtr++);
++- }
+++static inline void volk_32f_64f_add_64f_u_avx(double* cVector,
+++ const float* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const unsigned int eighth_points = num_points / 8;
+++
+++ double* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const double* bPtr = bVector;
+++
+++ __m256 aVal;
+++ __m128 aVal1, aVal2;
+++ __m256d aDbl1, aDbl2, bVal1, bVal2, cVal1, cVal2;
+++ for (; number < eighth_points; number++) {
+++
+++ aVal = _mm256_loadu_ps(aPtr);
+++ bVal1 = _mm256_loadu_pd(bPtr);
+++ bVal2 = _mm256_loadu_pd(bPtr + 4);
+++
+++ aVal1 = _mm256_extractf128_ps(aVal, 0);
+++ aVal2 = _mm256_extractf128_ps(aVal, 1);
+++
+++ aDbl1 = _mm256_cvtps_pd(aVal1);
+++ aDbl2 = _mm256_cvtps_pd(aVal2);
+++
+++ cVal1 = _mm256_add_pd(aDbl1, bVal1);
+++ cVal2 = _mm256_add_pd(aDbl2, bVal2);
+++
+++ _mm256_storeu_pd(cPtr,
+++ cVal1); // Store the results back into the C container
+++ _mm256_storeu_pd(cPtr + 4,
+++ cVal2); // Store the results back into the C container
+++
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
+++
+++ number = eighth_points * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = ((double)(*aPtr++)) + (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++@@ -193,48 +196,49 @@ static inline void volk_32f_64f_add_64f_u_avx(double *cVector,
++ #include <immintrin.h>
++ #include <xmmintrin.h>
++
++-static inline void volk_32f_64f_add_64f_a_avx(double *cVector,
++- const float *aVector,
++- const double *bVector,
++- unsigned int num_points) {
++- unsigned int number = 0;
++- const unsigned int eighth_points = num_points / 8;
++-
++- double *cPtr = cVector;
++- const float *aPtr = aVector;
++- const double *bPtr = bVector;
++-
++- __m256 aVal;
++- __m128 aVal1, aVal2;
++- __m256d aDbl1, aDbl2, bVal1, bVal2, cVal1, cVal2;
++- for (; number < eighth_points; number++) {
++-
++- aVal = _mm256_load_ps(aPtr);
++- bVal1 = _mm256_load_pd(bPtr);
++- bVal2 = _mm256_load_pd(bPtr + 4);
++-
++- aVal1 = _mm256_extractf128_ps(aVal, 0);
++- aVal2 = _mm256_extractf128_ps(aVal, 1);
++-
++- aDbl1 = _mm256_cvtps_pd(aVal1);
++- aDbl2 = _mm256_cvtps_pd(aVal2);
++-
++- cVal1 = _mm256_add_pd(aDbl1, bVal1);
++- cVal2 = _mm256_add_pd(aDbl2, bVal2);
++-
++- _mm256_store_pd(cPtr, cVal1); // Store the results back into the C container
++- _mm256_store_pd(cPtr + 4,
++- cVal2); // Store the results back into the C container
++-
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
++-
++- number = eighth_points * 8;
++- for (; number < num_points; number++) {
++- *cPtr++ = ((double)(*aPtr++)) + (*bPtr++);
++- }
+++static inline void volk_32f_64f_add_64f_a_avx(double* cVector,
+++ const float* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const unsigned int eighth_points = num_points / 8;
+++
+++ double* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const double* bPtr = bVector;
+++
+++ __m256 aVal;
+++ __m128 aVal1, aVal2;
+++ __m256d aDbl1, aDbl2, bVal1, bVal2, cVal1, cVal2;
+++ for (; number < eighth_points; number++) {
+++
+++ aVal = _mm256_load_ps(aPtr);
+++ bVal1 = _mm256_load_pd(bPtr);
+++ bVal2 = _mm256_load_pd(bPtr + 4);
+++
+++ aVal1 = _mm256_extractf128_ps(aVal, 0);
+++ aVal2 = _mm256_extractf128_ps(aVal, 1);
+++
+++ aDbl1 = _mm256_cvtps_pd(aVal1);
+++ aDbl2 = _mm256_cvtps_pd(aVal2);
+++
+++ cVal1 = _mm256_add_pd(aDbl1, bVal1);
+++ cVal2 = _mm256_add_pd(aDbl2, bVal2);
+++
+++ _mm256_store_pd(cPtr, cVal1); // Store the results back into the C container
+++ _mm256_store_pd(cPtr + 4,
+++ cVal2); // Store the results back into the C container
+++
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
+++
+++ number = eighth_points * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = ((double)(*aPtr++)) + (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++diff --git a/kernels/volk/volk_32f_64f_multiply_64f.h b/kernels/volk/volk_32f_64f_multiply_64f.h
++index 50f08a1..1039850 100644
++--- a/kernels/volk/volk_32f_64f_multiply_64f.h
+++++ b/kernels/volk/volk_32f_64f_multiply_64f.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_64f_multiply_64f(double* cVector, const double* aVector, const double* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_64f_multiply_64f(double* cVector, const double* aVector, const double*
+++ * bVector, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: First input vector.
++@@ -76,18 +76,19 @@
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_64f_multiply_64f_generic(double *cVector, const float *aVector,
++- const double *bVector, unsigned int num_points)
+++static inline void volk_32f_64f_multiply_64f_generic(double* cVector,
+++ const float* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- double *cPtr = cVector;
++- const float *aPtr = aVector;
++- const double *bPtr = bVector;
++- unsigned int number = 0;
++-
++- for (number = 0; number < num_points; number++) {
++- *cPtr++ = ((double)(*aPtr++)) * (*bPtr++);
++- }
+++ double* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const double* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = ((double)(*aPtr++)) * (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -102,47 +103,48 @@ volk_32f_64f_multiply_64f_generic(double *cVector, const float *aVector,
++ #include <immintrin.h>
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_64f_multiply_64f_u_avx(double *cVector, const float *aVector,
++- const double *bVector, unsigned int num_points)
+++static inline void volk_32f_64f_multiply_64f_u_avx(double* cVector,
+++ const float* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighth_points = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighth_points = num_points / 8;
++
++- double *cPtr = cVector;
++- const float *aPtr = aVector;
++- const double *bPtr = bVector;
+++ double* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m256 aVal;
++- __m128 aVal1, aVal2;
++- __m256d aDbl1, aDbl2, bVal1, bVal2, cVal1, cVal2;
++- for (; number < eighth_points; number++) {
+++ __m256 aVal;
+++ __m128 aVal1, aVal2;
+++ __m256d aDbl1, aDbl2, bVal1, bVal2, cVal1, cVal2;
+++ for (; number < eighth_points; number++) {
++
++- aVal = _mm256_loadu_ps(aPtr);
++- bVal1 = _mm256_loadu_pd(bPtr);
++- bVal2 = _mm256_loadu_pd(bPtr+4);
+++ aVal = _mm256_loadu_ps(aPtr);
+++ bVal1 = _mm256_loadu_pd(bPtr);
+++ bVal2 = _mm256_loadu_pd(bPtr + 4);
++
++- aVal1 = _mm256_extractf128_ps(aVal, 0);
++- aVal2 = _mm256_extractf128_ps(aVal, 1);
+++ aVal1 = _mm256_extractf128_ps(aVal, 0);
+++ aVal2 = _mm256_extractf128_ps(aVal, 1);
++
++- aDbl1 = _mm256_cvtps_pd(aVal1);
++- aDbl2 = _mm256_cvtps_pd(aVal2);
+++ aDbl1 = _mm256_cvtps_pd(aVal1);
+++ aDbl2 = _mm256_cvtps_pd(aVal2);
++
++- cVal1 = _mm256_mul_pd(aDbl1, bVal1);
++- cVal2 = _mm256_mul_pd(aDbl2, bVal2);
+++ cVal1 = _mm256_mul_pd(aDbl1, bVal1);
+++ cVal2 = _mm256_mul_pd(aDbl2, bVal2);
++
++- _mm256_storeu_pd(cPtr, cVal1); // Store the results back into the C container
++- _mm256_storeu_pd(cPtr+4, cVal2); // Store the results back into the C container
+++ _mm256_storeu_pd(cPtr, cVal1); // Store the results back into the C container
+++ _mm256_storeu_pd(cPtr + 4, cVal2); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighth_points * 8;
++- for (; number < num_points; number++) {
++- *cPtr++ = ((double)(*aPtr++)) * (*bPtr++);
++- }
+++ number = eighth_points * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = ((double)(*aPtr++)) * (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++@@ -153,51 +155,51 @@ volk_32f_64f_multiply_64f_u_avx(double *cVector, const float *aVector,
++ #include <immintrin.h>
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_64f_multiply_64f_a_avx(double *cVector, const float *aVector,
++- const double *bVector, unsigned int num_points)
+++static inline void volk_32f_64f_multiply_64f_a_avx(double* cVector,
+++ const float* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighth_points = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighth_points = num_points / 8;
++
++- double *cPtr = cVector;
++- const float *aPtr = aVector;
++- const double *bPtr = bVector;
+++ double* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m256 aVal;
++- __m128 aVal1, aVal2;
++- __m256d aDbl1, aDbl2, bVal1, bVal2, cVal1, cVal2;
++- for (; number < eighth_points; number++) {
+++ __m256 aVal;
+++ __m128 aVal1, aVal2;
+++ __m256d aDbl1, aDbl2, bVal1, bVal2, cVal1, cVal2;
+++ for (; number < eighth_points; number++) {
++
++- aVal = _mm256_load_ps(aPtr);
++- bVal1 = _mm256_load_pd(bPtr);
++- bVal2 = _mm256_load_pd(bPtr+4);
+++ aVal = _mm256_load_ps(aPtr);
+++ bVal1 = _mm256_load_pd(bPtr);
+++ bVal2 = _mm256_load_pd(bPtr + 4);
++
++- aVal1 = _mm256_extractf128_ps(aVal, 0);
++- aVal2 = _mm256_extractf128_ps(aVal, 1);
+++ aVal1 = _mm256_extractf128_ps(aVal, 0);
+++ aVal2 = _mm256_extractf128_ps(aVal, 1);
++
++- aDbl1 = _mm256_cvtps_pd(aVal1);
++- aDbl2 = _mm256_cvtps_pd(aVal2);
+++ aDbl1 = _mm256_cvtps_pd(aVal1);
+++ aDbl2 = _mm256_cvtps_pd(aVal2);
++
++- cVal1 = _mm256_mul_pd(aDbl1, bVal1);
++- cVal2 = _mm256_mul_pd(aDbl2, bVal2);
+++ cVal1 = _mm256_mul_pd(aDbl1, bVal1);
+++ cVal2 = _mm256_mul_pd(aDbl2, bVal2);
++
++- _mm256_store_pd(cPtr, cVal1); // Store the results back into the C container
++- _mm256_store_pd(cPtr+4, cVal2); // Store the results back into the C container
+++ _mm256_store_pd(cPtr, cVal1); // Store the results back into the C container
+++ _mm256_store_pd(cPtr + 4, cVal2); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighth_points * 8;
++- for (; number < num_points; number++) {
++- *cPtr++ = ((double)(*aPtr++)) * (*bPtr++);
++- }
+++ number = eighth_points * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = ((double)(*aPtr++)) * (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++
++
++-
++ #endif /* INCLUDED_volk_32f_64f_multiply_64f_u_H */
++diff --git a/kernels/volk/volk_32f_8u_polarbutterfly_32f.h b/kernels/volk/volk_32f_8u_polarbutterfly_32f.h
++index 4aba6c4..2198b33 100644
++--- a/kernels/volk/volk_32f_8u_polarbutterfly_32f.h
+++++ b/kernels/volk/volk_32f_8u_polarbutterfly_32f.h
++@@ -51,14 +51,17 @@
++ * int frame_exp = 10;
++ * int frame_size = 0x01 << frame_exp;
++ *
++- * float* llrs = (float*) volk_malloc(sizeof(float) * frame_size * (frame_exp + 1), volk_get_alignment());
++- * unsigned char* u = (unsigned char) volk_malloc(sizeof(unsigned char) * frame_size * (frame_exp + 1), volk_get_alignment());
+++ * float* llrs = (float*) volk_malloc(sizeof(float) * frame_size * (frame_exp + 1),
+++ * volk_get_alignment()); unsigned char* u = (unsigned char) volk_malloc(sizeof(unsigned
+++ * char) * frame_size * (frame_exp + 1), volk_get_alignment());
++ *
++- * {some_function_to_write_encoded_bits_to_float_llrs(llrs + frame_size * frame_exp, data)};
+++ * {some_function_to_write_encoded_bits_to_float_llrs(llrs + frame_size * frame_exp,
+++ * data)};
++ *
++ * unsigned int u_num;
++ * for(u_num = 0; u_num < frame_size; u_num++){
++- * volk_32f_8u_polarbutterfly_32f_u_avx(llrs, u, frame_size, frame_exp, 0, u_num, u_num);
+++ * volk_32f_8u_polarbutterfly_32f_u_avx(llrs, u, frame_size, frame_exp, 0, u_num,
+++ * u_num);
++ * // next line could first search for frozen bit value and then do bit decision.
++ * u[u_num] = llrs[u_num] > 0 ? 0 : 1;
++ * }
++@@ -73,130 +76,131 @@
++ #include <math.h>
++ #include <volk/volk_8u_x2_encodeframepolar_8u.h>
++
++-static inline float
++-llr_odd(const float la, const float lb)
+++static inline float llr_odd(const float la, const float lb)
++ {
++- const float ala = fabsf(la);
++- const float alb = fabsf(lb);
++- return copysignf(1.0f, la) * copysignf(1.0f, lb) * (ala > alb ? alb : ala);
+++ const float ala = fabsf(la);
+++ const float alb = fabsf(lb);
+++ return copysignf(1.0f, la) * copysignf(1.0f, lb) * (ala > alb ? alb : ala);
++ }
++
++-static inline void
++-llr_odd_stages(float* llrs, int min_stage, const int depth, const int frame_size, const int row)
+++static inline void llr_odd_stages(
+++ float* llrs, int min_stage, const int depth, const int frame_size, const int row)
++ {
++- int loop_stage = depth - 1;
++- float* dst_llr_ptr;
++- float* src_llr_ptr;
++- int stage_size = 0x01 << loop_stage;
++-
++- int el;
++- while(min_stage <= loop_stage){
++- dst_llr_ptr = llrs + loop_stage * frame_size + row;
++- src_llr_ptr = dst_llr_ptr + frame_size;
++- for(el = 0; el < stage_size; el++){
++- *dst_llr_ptr++ = llr_odd(*src_llr_ptr, *(src_llr_ptr + 1));
++- src_llr_ptr += 2;
+++ int loop_stage = depth - 1;
+++ float* dst_llr_ptr;
+++ float* src_llr_ptr;
+++ int stage_size = 0x01 << loop_stage;
+++
+++ int el;
+++ while (min_stage <= loop_stage) {
+++ dst_llr_ptr = llrs + loop_stage * frame_size + row;
+++ src_llr_ptr = dst_llr_ptr + frame_size;
+++ for (el = 0; el < stage_size; el++) {
+++ *dst_llr_ptr++ = llr_odd(*src_llr_ptr, *(src_llr_ptr + 1));
+++ src_llr_ptr += 2;
+++ }
+++
+++ --loop_stage;
+++ stage_size >>= 1;
++ }
++-
++- --loop_stage;
++- stage_size >>= 1;
++- }
++ }
++
++-static inline float
++-llr_even(const float la, const float lb, const unsigned char f)
+++static inline float llr_even(const float la, const float lb, const unsigned char f)
++ {
++- switch(f){
+++ switch (f) {
++ case 0:
++- return lb + la;
+++ return lb + la;
++ default:
++- return lb - la;
++- }
+++ return lb - la;
+++ }
++ }
++
++ static inline void
++ even_u_values(unsigned char* u_even, const unsigned char* u, const int u_num)
++ {
++- u++;
++- int i;
++- for(i = 1; i < u_num; i += 2){
++- *u_even++ = *u;
++- u += 2;
++- }
+++ u++;
+++ int i;
+++ for (i = 1; i < u_num; i += 2) {
+++ *u_even++ = *u;
+++ u += 2;
+++ }
++ }
++
++ static inline void
++ odd_xor_even_values(unsigned char* u_xor, const unsigned char* u, const int u_num)
++ {
++- int i;
++- for(i = 1; i < u_num; i += 2){
++- *u_xor++ = *u ^ *(u + 1);
++- u += 2;
++- }
+++ int i;
+++ for (i = 1; i < u_num; i += 2) {
+++ *u_xor++ = *u ^ *(u + 1);
+++ u += 2;
+++ }
++ }
++
++-static inline int
++-calculate_max_stage_depth_for_row(const int frame_exp, const int row)
+++static inline int calculate_max_stage_depth_for_row(const int frame_exp, const int row)
++ {
++- int max_stage_depth = 0;
++- int half_stage_size = 0x01;
++- int stage_size = half_stage_size << 1;
++- while(max_stage_depth < (frame_exp - 1)){ // last stage holds received values.
++- if(!(row % stage_size < half_stage_size)){
++- break;
+++ int max_stage_depth = 0;
+++ int half_stage_size = 0x01;
+++ int stage_size = half_stage_size << 1;
+++ while (max_stage_depth < (frame_exp - 1)) { // last stage holds received values.
+++ if (!(row % stage_size < half_stage_size)) {
+++ break;
+++ }
+++ half_stage_size <<= 1;
+++ stage_size <<= 1;
+++ max_stage_depth++;
++ }
++- half_stage_size <<= 1;
++- stage_size <<= 1;
++- max_stage_depth++;
++- }
++- return max_stage_depth;
+++ return max_stage_depth;
++ }
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_8u_polarbutterfly_32f_generic(float* llrs, unsigned char* u,
++- const int frame_exp,
++- const int stage, const int u_num, const int row)
+++static inline void volk_32f_8u_polarbutterfly_32f_generic(float* llrs,
+++ unsigned char* u,
+++ const int frame_exp,
+++ const int stage,
+++ const int u_num,
+++ const int row)
++ {
++- const int frame_size = 0x01 << frame_exp;
++- const int next_stage = stage + 1;
+++ const int frame_size = 0x01 << frame_exp;
+++ const int next_stage = stage + 1;
++
++- const int half_stage_size = 0x01 << stage;
++- const int stage_size = half_stage_size << 1;
+++ const int half_stage_size = 0x01 << stage;
+++ const int stage_size = half_stage_size << 1;
++
++- const bool is_upper_stage_half = row % stage_size < half_stage_size;
+++ const bool is_upper_stage_half = row % stage_size < half_stage_size;
++
++-// // this is a natural bit order impl
++- float* next_llrs = llrs + frame_size;// LLRs are stored in a consecutive array.
++- float* call_row_llr = llrs + row;
+++ // // this is a natural bit order impl
+++ float* next_llrs = llrs + frame_size; // LLRs are stored in a consecutive array.
+++ float* call_row_llr = llrs + row;
++
++- const int section = row - (row % stage_size);
++- const int jump_size = ((row % half_stage_size) << 1) % stage_size;
+++ const int section = row - (row % stage_size);
+++ const int jump_size = ((row % half_stage_size) << 1) % stage_size;
++
++- const int next_upper_row = section + jump_size;
++- const int next_lower_row = next_upper_row + 1;
+++ const int next_upper_row = section + jump_size;
+++ const int next_lower_row = next_upper_row + 1;
++
++- const float* upper_right_llr_ptr = next_llrs + next_upper_row;
++- const float* lower_right_llr_ptr = next_llrs + next_lower_row;
+++ const float* upper_right_llr_ptr = next_llrs + next_upper_row;
+++ const float* lower_right_llr_ptr = next_llrs + next_lower_row;
++
++- if(!is_upper_stage_half){
++- const int u_pos = u_num >> stage;
++- const unsigned char f = u[u_pos - 1];
++- *call_row_llr = llr_even(*upper_right_llr_ptr, *lower_right_llr_ptr, f);
++- return;
++- }
+++ if (!is_upper_stage_half) {
+++ const int u_pos = u_num >> stage;
+++ const unsigned char f = u[u_pos - 1];
+++ *call_row_llr = llr_even(*upper_right_llr_ptr, *lower_right_llr_ptr, f);
+++ return;
+++ }
++
++- if(frame_exp > next_stage){
++- unsigned char* u_half = u + frame_size;
++- odd_xor_even_values(u_half, u, u_num);
++- volk_32f_8u_polarbutterfly_32f_generic(next_llrs, u_half, frame_exp, next_stage, u_num, next_upper_row);
+++ if (frame_exp > next_stage) {
+++ unsigned char* u_half = u + frame_size;
+++ odd_xor_even_values(u_half, u, u_num);
+++ volk_32f_8u_polarbutterfly_32f_generic(
+++ next_llrs, u_half, frame_exp, next_stage, u_num, next_upper_row);
++
++- even_u_values(u_half, u, u_num);
++- volk_32f_8u_polarbutterfly_32f_generic(next_llrs, u_half, frame_exp, next_stage, u_num, next_lower_row);
++- }
+++ even_u_values(u_half, u, u_num);
+++ volk_32f_8u_polarbutterfly_32f_generic(
+++ next_llrs, u_half, frame_exp, next_stage, u_num, next_lower_row);
+++ }
++
++- *call_row_llr = llr_odd(*upper_right_llr_ptr, *lower_right_llr_ptr);
+++ *call_row_llr = llr_odd(*upper_right_llr_ptr, *lower_right_llr_ptr);
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -206,99 +210,99 @@ volk_32f_8u_polarbutterfly_32f_generic(float* llrs, unsigned char* u,
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void
++-volk_32f_8u_polarbutterfly_32f_u_avx(float* llrs, unsigned char* u,
++- const int frame_exp,
++- const int stage, const int u_num, const int row)
+++static inline void volk_32f_8u_polarbutterfly_32f_u_avx(float* llrs,
+++ unsigned char* u,
+++ const int frame_exp,
+++ const int stage,
+++ const int u_num,
+++ const int row)
++ {
++- const int frame_size = 0x01 << frame_exp;
++- if(row % 2){ // for odd rows just do the only necessary calculation and return.
++- const float* next_llrs = llrs + frame_size + row;
++- *(llrs + row) = llr_even(*(next_llrs - 1), *next_llrs, u[u_num - 1]);
++- return;
++- }
++-
++- const int max_stage_depth = calculate_max_stage_depth_for_row(frame_exp, row);
++- if(max_stage_depth < 3){ // vectorized version needs larger vectors.
++- volk_32f_8u_polarbutterfly_32f_generic(llrs, u, frame_exp, stage, u_num, row);
++- return;
++- }
++-
++- int loop_stage = max_stage_depth;
++- int stage_size = 0x01 << loop_stage;
++-
++- float* src_llr_ptr;
++- float* dst_llr_ptr;
++-
++- __m256 src0, src1, dst;
++-
++- if(row){ // not necessary for ZERO row. == first bit to be decoded.
++- // first do bit combination for all stages
++- // effectively encode some decoded bits again.
++- unsigned char* u_target = u + frame_size;
++- unsigned char* u_temp = u + 2* frame_size;
++- memcpy(u_temp, u + u_num - stage_size, sizeof(unsigned char) * stage_size);
++-
++- if(stage_size > 15){
++- _mm256_zeroupper();
++- volk_8u_x2_encodeframepolar_8u_u_ssse3(u_target, u_temp, stage_size);
+++ const int frame_size = 0x01 << frame_exp;
+++ if (row % 2) { // for odd rows just do the only necessary calculation and return.
+++ const float* next_llrs = llrs + frame_size + row;
+++ *(llrs + row) = llr_even(*(next_llrs - 1), *next_llrs, u[u_num - 1]);
+++ return;
++ }
++- else{
++- volk_8u_x2_encodeframepolar_8u_generic(u_target, u_temp, stage_size);
+++
+++ const int max_stage_depth = calculate_max_stage_depth_for_row(frame_exp, row);
+++ if (max_stage_depth < 3) { // vectorized version needs larger vectors.
+++ volk_32f_8u_polarbutterfly_32f_generic(llrs, u, frame_exp, stage, u_num, row);
+++ return;
++ }
++
++- src_llr_ptr = llrs + (max_stage_depth + 1) * frame_size + row - stage_size;
++- dst_llr_ptr = llrs + max_stage_depth * frame_size + row;
+++ int loop_stage = max_stage_depth;
+++ int stage_size = 0x01 << loop_stage;
++
++- __m128i fbits;
+++ float* src_llr_ptr;
+++ float* dst_llr_ptr;
++
++- int p;
++- for(p = 0; p < stage_size; p += 8){
++- _mm256_zeroupper();
++- fbits = _mm_loadu_si128((__m128i*) u_target);
++- u_target += 8;
+++ __m256 src0, src1, dst;
++
++- src0 = _mm256_loadu_ps(src_llr_ptr);
++- src1 = _mm256_loadu_ps(src_llr_ptr + 8);
++- src_llr_ptr += 16;
+++ if (row) { // not necessary for ZERO row. == first bit to be decoded.
+++ // first do bit combination for all stages
+++ // effectively encode some decoded bits again.
+++ unsigned char* u_target = u + frame_size;
+++ unsigned char* u_temp = u + 2 * frame_size;
+++ memcpy(u_temp, u + u_num - stage_size, sizeof(unsigned char) * stage_size);
++
++- dst = _mm256_polar_fsign_add_llrs(src0, src1, fbits);
+++ if (stage_size > 15) {
+++ _mm256_zeroupper();
+++ volk_8u_x2_encodeframepolar_8u_u_ssse3(u_target, u_temp, stage_size);
+++ } else {
+++ volk_8u_x2_encodeframepolar_8u_generic(u_target, u_temp, stage_size);
+++ }
++
++- _mm256_storeu_ps(dst_llr_ptr, dst);
++- dst_llr_ptr += 8;
++- }
+++ src_llr_ptr = llrs + (max_stage_depth + 1) * frame_size + row - stage_size;
+++ dst_llr_ptr = llrs + max_stage_depth * frame_size + row;
++
++- --loop_stage;
++- stage_size >>= 1;
++- }
+++ __m128i fbits;
++
++- const int min_stage = stage > 2 ? stage : 2;
+++ int p;
+++ for (p = 0; p < stage_size; p += 8) {
+++ _mm256_zeroupper();
+++ fbits = _mm_loadu_si128((__m128i*)u_target);
+++ u_target += 8;
++
++- _mm256_zeroall(); // Important to clear cache!
+++ src0 = _mm256_loadu_ps(src_llr_ptr);
+++ src1 = _mm256_loadu_ps(src_llr_ptr + 8);
+++ src_llr_ptr += 16;
++
++- int el;
++- while(min_stage < loop_stage){
++- dst_llr_ptr = llrs + loop_stage * frame_size + row;
++- src_llr_ptr = dst_llr_ptr + frame_size;
++- for(el = 0; el < stage_size; el += 8){
++- src0 = _mm256_loadu_ps(src_llr_ptr);
++- src_llr_ptr += 8;
++- src1 = _mm256_loadu_ps(src_llr_ptr);
++- src_llr_ptr += 8;
+++ dst = _mm256_polar_fsign_add_llrs(src0, src1, fbits);
++
++- dst = _mm256_polar_minsum_llrs(src0, src1);
+++ _mm256_storeu_ps(dst_llr_ptr, dst);
+++ dst_llr_ptr += 8;
+++ }
++
++- _mm256_storeu_ps(dst_llr_ptr, dst);
++- dst_llr_ptr += 8;
+++ --loop_stage;
+++ stage_size >>= 1;
++ }
++
++- --loop_stage;
++- stage_size >>= 1;
+++ const int min_stage = stage > 2 ? stage : 2;
+++
+++ _mm256_zeroall(); // Important to clear cache!
++
++- }
+++ int el;
+++ while (min_stage < loop_stage) {
+++ dst_llr_ptr = llrs + loop_stage * frame_size + row;
+++ src_llr_ptr = dst_llr_ptr + frame_size;
+++ for (el = 0; el < stage_size; el += 8) {
+++ src0 = _mm256_loadu_ps(src_llr_ptr);
+++ src_llr_ptr += 8;
+++ src1 = _mm256_loadu_ps(src_llr_ptr);
+++ src_llr_ptr += 8;
++
++- // for stages < 3 vectors are too small!.
++- llr_odd_stages(llrs, stage, loop_stage + 1,frame_size, row);
+++ dst = _mm256_polar_minsum_llrs(src0, src1);
+++
+++ _mm256_storeu_ps(dst_llr_ptr, dst);
+++ dst_llr_ptr += 8;
+++ }
+++
+++ --loop_stage;
+++ stage_size >>= 1;
+++ }
+++
+++ // for stages < 3 vectors are too small!.
+++ llr_odd_stages(llrs, stage, loop_stage + 1, frame_size, row);
++ }
++
++ #endif /* LV_HAVE_AVX */
++@@ -307,99 +311,99 @@ volk_32f_8u_polarbutterfly_32f_u_avx(float* llrs, unsigned char* u,
++ #include <immintrin.h>
++ #include <volk/volk_avx2_intrinsics.h>
++
++-static inline void
++-volk_32f_8u_polarbutterfly_32f_u_avx2(float* llrs, unsigned char* u,
++- const int frame_exp,
++- const int stage, const int u_num, const int row)
+++static inline void volk_32f_8u_polarbutterfly_32f_u_avx2(float* llrs,
+++ unsigned char* u,
+++ const int frame_exp,
+++ const int stage,
+++ const int u_num,
+++ const int row)
++ {
++- const int frame_size = 0x01 << frame_exp;
++- if(row % 2){ // for odd rows just do the only necessary calculation and return.
++- const float* next_llrs = llrs + frame_size + row;
++- *(llrs + row) = llr_even(*(next_llrs - 1), *next_llrs, u[u_num - 1]);
++- return;
++- }
++-
++- const int max_stage_depth = calculate_max_stage_depth_for_row(frame_exp, row);
++- if(max_stage_depth < 3){ // vectorized version needs larger vectors.
++- volk_32f_8u_polarbutterfly_32f_generic(llrs, u, frame_exp, stage, u_num, row);
++- return;
++- }
++-
++- int loop_stage = max_stage_depth;
++- int stage_size = 0x01 << loop_stage;
++-
++- float* src_llr_ptr;
++- float* dst_llr_ptr;
++-
++- __m256 src0, src1, dst;
++-
++- if(row){ // not necessary for ZERO row. == first bit to be decoded.
++- // first do bit combination for all stages
++- // effectively encode some decoded bits again.
++- unsigned char* u_target = u + frame_size;
++- unsigned char* u_temp = u + 2* frame_size;
++- memcpy(u_temp, u + u_num - stage_size, sizeof(unsigned char) * stage_size);
++-
++- if(stage_size > 15){
++- _mm256_zeroupper();
++- volk_8u_x2_encodeframepolar_8u_u_ssse3(u_target, u_temp, stage_size);
+++ const int frame_size = 0x01 << frame_exp;
+++ if (row % 2) { // for odd rows just do the only necessary calculation and return.
+++ const float* next_llrs = llrs + frame_size + row;
+++ *(llrs + row) = llr_even(*(next_llrs - 1), *next_llrs, u[u_num - 1]);
+++ return;
++ }
++- else{
++- volk_8u_x2_encodeframepolar_8u_generic(u_target, u_temp, stage_size);
+++
+++ const int max_stage_depth = calculate_max_stage_depth_for_row(frame_exp, row);
+++ if (max_stage_depth < 3) { // vectorized version needs larger vectors.
+++ volk_32f_8u_polarbutterfly_32f_generic(llrs, u, frame_exp, stage, u_num, row);
+++ return;
++ }
++
++- src_llr_ptr = llrs + (max_stage_depth + 1) * frame_size + row - stage_size;
++- dst_llr_ptr = llrs + max_stage_depth * frame_size + row;
+++ int loop_stage = max_stage_depth;
+++ int stage_size = 0x01 << loop_stage;
++
++- __m128i fbits;
+++ float* src_llr_ptr;
+++ float* dst_llr_ptr;
++
++- int p;
++- for(p = 0; p < stage_size; p += 8){
++- _mm256_zeroupper();
++- fbits = _mm_loadu_si128((__m128i*) u_target);
++- u_target += 8;
+++ __m256 src0, src1, dst;
++
++- src0 = _mm256_loadu_ps(src_llr_ptr);
++- src1 = _mm256_loadu_ps(src_llr_ptr + 8);
++- src_llr_ptr += 16;
+++ if (row) { // not necessary for ZERO row. == first bit to be decoded.
+++ // first do bit combination for all stages
+++ // effectively encode some decoded bits again.
+++ unsigned char* u_target = u + frame_size;
+++ unsigned char* u_temp = u + 2 * frame_size;
+++ memcpy(u_temp, u + u_num - stage_size, sizeof(unsigned char) * stage_size);
++
++- dst = _mm256_polar_fsign_add_llrs_avx2(src0, src1, fbits);
+++ if (stage_size > 15) {
+++ _mm256_zeroupper();
+++ volk_8u_x2_encodeframepolar_8u_u_ssse3(u_target, u_temp, stage_size);
+++ } else {
+++ volk_8u_x2_encodeframepolar_8u_generic(u_target, u_temp, stage_size);
+++ }
++
++- _mm256_storeu_ps(dst_llr_ptr, dst);
++- dst_llr_ptr += 8;
++- }
+++ src_llr_ptr = llrs + (max_stage_depth + 1) * frame_size + row - stage_size;
+++ dst_llr_ptr = llrs + max_stage_depth * frame_size + row;
++
++- --loop_stage;
++- stage_size >>= 1;
++- }
+++ __m128i fbits;
++
++- const int min_stage = stage > 2 ? stage : 2;
+++ int p;
+++ for (p = 0; p < stage_size; p += 8) {
+++ _mm256_zeroupper();
+++ fbits = _mm_loadu_si128((__m128i*)u_target);
+++ u_target += 8;
++
++- _mm256_zeroall(); // Important to clear cache!
+++ src0 = _mm256_loadu_ps(src_llr_ptr);
+++ src1 = _mm256_loadu_ps(src_llr_ptr + 8);
+++ src_llr_ptr += 16;
++
++- int el;
++- while(min_stage < loop_stage){
++- dst_llr_ptr = llrs + loop_stage * frame_size + row;
++- src_llr_ptr = dst_llr_ptr + frame_size;
++- for(el = 0; el < stage_size; el += 8){
++- src0 = _mm256_loadu_ps(src_llr_ptr);
++- src_llr_ptr += 8;
++- src1 = _mm256_loadu_ps(src_llr_ptr);
++- src_llr_ptr += 8;
+++ dst = _mm256_polar_fsign_add_llrs_avx2(src0, src1, fbits);
++
++- dst = _mm256_polar_minsum_llrs(src0, src1);
+++ _mm256_storeu_ps(dst_llr_ptr, dst);
+++ dst_llr_ptr += 8;
+++ }
++
++- _mm256_storeu_ps(dst_llr_ptr, dst);
++- dst_llr_ptr += 8;
+++ --loop_stage;
+++ stage_size >>= 1;
++ }
++
++- --loop_stage;
++- stage_size >>= 1;
+++ const int min_stage = stage > 2 ? stage : 2;
+++
+++ _mm256_zeroall(); // Important to clear cache!
+++
+++ int el;
+++ while (min_stage < loop_stage) {
+++ dst_llr_ptr = llrs + loop_stage * frame_size + row;
+++ src_llr_ptr = dst_llr_ptr + frame_size;
+++ for (el = 0; el < stage_size; el += 8) {
+++ src0 = _mm256_loadu_ps(src_llr_ptr);
+++ src_llr_ptr += 8;
+++ src1 = _mm256_loadu_ps(src_llr_ptr);
+++ src_llr_ptr += 8;
++
++- }
+++ dst = _mm256_polar_minsum_llrs(src0, src1);
+++
+++ _mm256_storeu_ps(dst_llr_ptr, dst);
+++ dst_llr_ptr += 8;
+++ }
+++
+++ --loop_stage;
+++ stage_size >>= 1;
+++ }
++
++- // for stages < 3 vectors are too small!.
++- llr_odd_stages(llrs, stage, loop_stage + 1,frame_size, row);
+++ // for stages < 3 vectors are too small!.
+++ llr_odd_stages(llrs, stage, loop_stage + 1, frame_size, row);
++ }
++
++ #endif /* LV_HAVE_AVX2 */
++diff --git a/kernels/volk/volk_32f_8u_polarbutterflypuppet_32f.h b/kernels/volk/volk_32f_8u_polarbutterflypuppet_32f.h
++index fa40a86..6f97dd1 100644
++--- a/kernels/volk/volk_32f_8u_polarbutterflypuppet_32f.h
+++++ b/kernels/volk/volk_32f_8u_polarbutterflypuppet_32f.h
++@@ -33,124 +33,129 @@
++ #include <volk/volk_8u_x3_encodepolarpuppet_8u.h>
++
++
++-static inline void
++-sanitize_bytes(unsigned char* u, const int elements)
+++static inline void sanitize_bytes(unsigned char* u, const int elements)
++ {
++- int i;
++- unsigned char* u_ptr = u;
++- for(i = 0; i < elements; i++){
++- *u_ptr = (*u_ptr & 0x01);
++- u_ptr++;
++- }
+++ int i;
+++ unsigned char* u_ptr = u;
+++ for (i = 0; i < elements; i++) {
+++ *u_ptr = (*u_ptr & 0x01);
+++ u_ptr++;
+++ }
++ }
++
++-static inline void
++-clean_up_intermediate_values(float* llrs, unsigned char* u, const int frame_size, const int elements)
+++static inline void clean_up_intermediate_values(float* llrs,
+++ unsigned char* u,
+++ const int frame_size,
+++ const int elements)
++ {
++- memset(u + frame_size, 0, sizeof(unsigned char) * (elements - frame_size));
++- memset(llrs + frame_size, 0, sizeof(float) * (elements - frame_size));
+++ memset(u + frame_size, 0, sizeof(unsigned char) * (elements - frame_size));
+++ memset(llrs + frame_size, 0, sizeof(float) * (elements - frame_size));
++ }
++
++ static inline void
++ generate_error_free_input_vector(float* llrs, unsigned char* u, const int frame_size)
++ {
++- memset(u, 0, frame_size);
++- unsigned char* target = u + frame_size;
++- volk_8u_x2_encodeframepolar_8u_generic(target, u + 2 * frame_size, frame_size);
++- float* ft = llrs;
++- int i;
++- for(i = 0; i < frame_size; i++){
++- *ft = (-2 * ((float) *target++)) + 1.0f;
++- ft++;
++- }
+++ memset(u, 0, frame_size);
+++ unsigned char* target = u + frame_size;
+++ volk_8u_x2_encodeframepolar_8u_generic(target, u + 2 * frame_size, frame_size);
+++ float* ft = llrs;
+++ int i;
+++ for (i = 0; i < frame_size; i++) {
+++ *ft = (-2 * ((float)*target++)) + 1.0f;
+++ ft++;
+++ }
++ }
++
++ static inline void
++ print_llr_tree(const float* llrs, const int frame_size, const int frame_exp)
++ {
++- int s, e;
++- for(s = 0; s < frame_size; s++){
++- for(e = 0; e < frame_exp + 1; e++){
++- printf("%+4.2f ", llrs[e * frame_size + s]);
++- }
++- printf("\n");
++- if((s + 1) % 8 == 0){
++- printf("\n");
+++ int s, e;
+++ for (s = 0; s < frame_size; s++) {
+++ for (e = 0; e < frame_exp + 1; e++) {
+++ printf("%+4.2f ", llrs[e * frame_size + s]);
+++ }
+++ printf("\n");
+++ if ((s + 1) % 8 == 0) {
+++ printf("\n");
+++ }
++ }
++- }
++ }
++
++-static inline int
++-maximum_frame_size(const int elements)
+++static inline int maximum_frame_size(const int elements)
++ {
++- unsigned int frame_size = next_lower_power_of_two(elements);
++- unsigned int frame_exp = log2_of_power_of_2(frame_size);
++- return next_lower_power_of_two(frame_size / frame_exp);
+++ unsigned int frame_size = next_lower_power_of_two(elements);
+++ unsigned int frame_exp = log2_of_power_of_2(frame_size);
+++ return next_lower_power_of_two(frame_size / frame_exp);
++ }
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void
++-volk_32f_8u_polarbutterflypuppet_32f_generic(float* llrs, const float* input, unsigned char* u, const int elements)
+++static inline void volk_32f_8u_polarbutterflypuppet_32f_generic(float* llrs,
+++ const float* input,
+++ unsigned char* u,
+++ const int elements)
++ {
++- unsigned int frame_size = maximum_frame_size(elements);
++- unsigned int frame_exp = log2_of_power_of_2(frame_size);
+++ unsigned int frame_size = maximum_frame_size(elements);
+++ unsigned int frame_exp = log2_of_power_of_2(frame_size);
++
++- sanitize_bytes(u, elements);
++- clean_up_intermediate_values(llrs, u, frame_size, elements);
++- generate_error_free_input_vector(llrs + frame_exp * frame_size, u, frame_size);
+++ sanitize_bytes(u, elements);
+++ clean_up_intermediate_values(llrs, u, frame_size, elements);
+++ generate_error_free_input_vector(llrs + frame_exp * frame_size, u, frame_size);
++
++- unsigned int u_num = 0;
++- for(; u_num < frame_size; u_num++){
++- volk_32f_8u_polarbutterfly_32f_generic(llrs, u, frame_exp, 0, u_num, u_num);
++- u[u_num] = llrs[u_num] > 0 ? 0 : 1;
++- }
+++ unsigned int u_num = 0;
+++ for (; u_num < frame_size; u_num++) {
+++ volk_32f_8u_polarbutterfly_32f_generic(llrs, u, frame_exp, 0, u_num, u_num);
+++ u[u_num] = llrs[u_num] > 0 ? 0 : 1;
+++ }
++
++- clean_up_intermediate_values(llrs, u, frame_size, elements);
+++ clean_up_intermediate_values(llrs, u, frame_size, elements);
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_AVX
++-static inline void
++-volk_32f_8u_polarbutterflypuppet_32f_u_avx(float* llrs, const float* input, unsigned char* u, const int elements)
+++static inline void volk_32f_8u_polarbutterflypuppet_32f_u_avx(float* llrs,
+++ const float* input,
+++ unsigned char* u,
+++ const int elements)
++ {
++- unsigned int frame_size = maximum_frame_size(elements);
++- unsigned int frame_exp = log2_of_power_of_2(frame_size);
+++ unsigned int frame_size = maximum_frame_size(elements);
+++ unsigned int frame_exp = log2_of_power_of_2(frame_size);
++
++- sanitize_bytes(u, elements);
++- clean_up_intermediate_values(llrs, u, frame_size, elements);
++- generate_error_free_input_vector(llrs + frame_exp * frame_size, u, frame_size);
+++ sanitize_bytes(u, elements);
+++ clean_up_intermediate_values(llrs, u, frame_size, elements);
+++ generate_error_free_input_vector(llrs + frame_exp * frame_size, u, frame_size);
++
++- unsigned int u_num = 0;
++- for(; u_num < frame_size; u_num++){
++- volk_32f_8u_polarbutterfly_32f_u_avx(llrs, u, frame_exp, 0, u_num, u_num);
++- u[u_num] = llrs[u_num] > 0 ? 0 : 1;
++- }
+++ unsigned int u_num = 0;
+++ for (; u_num < frame_size; u_num++) {
+++ volk_32f_8u_polarbutterfly_32f_u_avx(llrs, u, frame_exp, 0, u_num, u_num);
+++ u[u_num] = llrs[u_num] > 0 ? 0 : 1;
+++ }
++
++- clean_up_intermediate_values(llrs, u, frame_size, elements);
+++ clean_up_intermediate_values(llrs, u, frame_size, elements);
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_AVX2
++-static inline void
++-volk_32f_8u_polarbutterflypuppet_32f_u_avx2(float* llrs, const float* input, unsigned char* u, const int elements)
+++static inline void volk_32f_8u_polarbutterflypuppet_32f_u_avx2(float* llrs,
+++ const float* input,
+++ unsigned char* u,
+++ const int elements)
++ {
++- unsigned int frame_size = maximum_frame_size(elements);
++- unsigned int frame_exp = log2_of_power_of_2(frame_size);
+++ unsigned int frame_size = maximum_frame_size(elements);
+++ unsigned int frame_exp = log2_of_power_of_2(frame_size);
++
++- sanitize_bytes(u, elements);
++- clean_up_intermediate_values(llrs, u, frame_size, elements);
++- generate_error_free_input_vector(llrs + frame_exp * frame_size, u, frame_size);
+++ sanitize_bytes(u, elements);
+++ clean_up_intermediate_values(llrs, u, frame_size, elements);
+++ generate_error_free_input_vector(llrs + frame_exp * frame_size, u, frame_size);
++
++- unsigned int u_num = 0;
++- for(; u_num < frame_size; u_num++){
++- volk_32f_8u_polarbutterfly_32f_u_avx2(llrs, u, frame_exp, 0, u_num, u_num);
++- u[u_num] = llrs[u_num] > 0 ? 0 : 1;
++- }
+++ unsigned int u_num = 0;
+++ for (; u_num < frame_size; u_num++) {
+++ volk_32f_8u_polarbutterfly_32f_u_avx2(llrs, u, frame_exp, 0, u_num, u_num);
+++ u[u_num] = llrs[u_num] > 0 ? 0 : 1;
+++ }
++
++- clean_up_intermediate_values(llrs, u, frame_size, elements);
+++ clean_up_intermediate_values(llrs, u, frame_size, elements);
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++
++-
++ #endif /* VOLK_KERNELS_VOLK_VOLK_32F_8U_POLARBUTTERFLYPUPPET_32F_H_ */
++diff --git a/kernels/volk/volk_32f_accumulator_s32f.h b/kernels/volk/volk_32f_accumulator_s32f.h
++index f6219c8..9a78f58 100644
++--- a/kernels/volk/volk_32f_accumulator_s32f.h
+++++ b/kernels/volk/volk_32f_accumulator_s32f.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_accumulator_s32f(float* result, const float* inputBuffer, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_accumulator_s32f(float* result, const float* inputBuffer, unsigned int
+++ * num_points) \endcode
++ *
++ * \b Inputs
++ * \li inputBuffer The buffer of data to be accumulated
++@@ -63,47 +63,48 @@
++ #ifndef INCLUDED_volk_32f_accumulator_s32f_a_H
++ #define INCLUDED_volk_32f_accumulator_s32f_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_accumulator_s32f_a_avx(float* result, const float* inputBuffer, unsigned int num_points)
+++static inline void volk_32f_accumulator_s32f_a_avx(float* result,
+++ const float* inputBuffer,
+++ unsigned int num_points)
++ {
++- float returnValue = 0;
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* aPtr = inputBuffer;
++- __VOLK_ATTR_ALIGNED(32) float tempBuffer[8];
++-
++- __m256 accumulator = _mm256_setzero_ps();
++- __m256 aVal = _mm256_setzero_ps();
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- accumulator = _mm256_add_ps(accumulator, aVal);
++- aPtr += 8;
++- }
++-
++- _mm256_store_ps(tempBuffer, accumulator);
++-
++- returnValue = tempBuffer[0];
++- returnValue += tempBuffer[1];
++- returnValue += tempBuffer[2];
++- returnValue += tempBuffer[3];
++- returnValue += tempBuffer[4];
++- returnValue += tempBuffer[5];
++- returnValue += tempBuffer[6];
++- returnValue += tempBuffer[7];
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- returnValue += (*aPtr++);
++- }
++- *result = returnValue;
+++ float returnValue = 0;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const float* aPtr = inputBuffer;
+++ __VOLK_ATTR_ALIGNED(32) float tempBuffer[8];
+++
+++ __m256 accumulator = _mm256_setzero_ps();
+++ __m256 aVal = _mm256_setzero_ps();
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ accumulator = _mm256_add_ps(accumulator, aVal);
+++ aPtr += 8;
+++ }
+++
+++ _mm256_store_ps(tempBuffer, accumulator);
+++
+++ returnValue = tempBuffer[0];
+++ returnValue += tempBuffer[1];
+++ returnValue += tempBuffer[2];
+++ returnValue += tempBuffer[3];
+++ returnValue += tempBuffer[4];
+++ returnValue += tempBuffer[5];
+++ returnValue += tempBuffer[6];
+++ returnValue += tempBuffer[7];
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ returnValue += (*aPtr++);
+++ }
+++ *result = returnValue;
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -111,41 +112,42 @@ volk_32f_accumulator_s32f_a_avx(float* result, const float* inputBuffer, unsigne
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_accumulator_s32f_u_avx(float* result, const float* inputBuffer, unsigned int num_points)
+++static inline void volk_32f_accumulator_s32f_u_avx(float* result,
+++ const float* inputBuffer,
+++ unsigned int num_points)
++ {
++- float returnValue = 0;
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* aPtr = inputBuffer;
++- __VOLK_ATTR_ALIGNED(32) float tempBuffer[8];
++-
++- __m256 accumulator = _mm256_setzero_ps();
++- __m256 aVal = _mm256_setzero_ps();
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- accumulator = _mm256_add_ps(accumulator, aVal);
++- aPtr += 8;
++- }
++-
++- _mm256_store_ps(tempBuffer, accumulator);
++-
++- returnValue = tempBuffer[0];
++- returnValue += tempBuffer[1];
++- returnValue += tempBuffer[2];
++- returnValue += tempBuffer[3];
++- returnValue += tempBuffer[4];
++- returnValue += tempBuffer[5];
++- returnValue += tempBuffer[6];
++- returnValue += tempBuffer[7];
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- returnValue += (*aPtr++);
++- }
++- *result = returnValue;
+++ float returnValue = 0;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const float* aPtr = inputBuffer;
+++ __VOLK_ATTR_ALIGNED(32) float tempBuffer[8];
+++
+++ __m256 accumulator = _mm256_setzero_ps();
+++ __m256 aVal = _mm256_setzero_ps();
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ accumulator = _mm256_add_ps(accumulator, aVal);
+++ aPtr += 8;
+++ }
+++
+++ _mm256_store_ps(tempBuffer, accumulator);
+++
+++ returnValue = tempBuffer[0];
+++ returnValue += tempBuffer[1];
+++ returnValue += tempBuffer[2];
+++ returnValue += tempBuffer[3];
+++ returnValue += tempBuffer[4];
+++ returnValue += tempBuffer[5];
+++ returnValue += tempBuffer[6];
+++ returnValue += tempBuffer[7];
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ returnValue += (*aPtr++);
+++ }
+++ *result = returnValue;
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -153,37 +155,38 @@ volk_32f_accumulator_s32f_u_avx(float* result, const float* inputBuffer, unsigne
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_accumulator_s32f_a_sse(float* result, const float* inputBuffer, unsigned int num_points)
+++static inline void volk_32f_accumulator_s32f_a_sse(float* result,
+++ const float* inputBuffer,
+++ unsigned int num_points)
++ {
++- float returnValue = 0;
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* aPtr = inputBuffer;
++- __VOLK_ATTR_ALIGNED(16) float tempBuffer[4];
++-
++- __m128 accumulator = _mm_setzero_ps();
++- __m128 aVal = _mm_setzero_ps();
++-
++- for(;number < quarterPoints; number++){
++- aVal = _mm_load_ps(aPtr);
++- accumulator = _mm_add_ps(accumulator, aVal);
++- aPtr += 4;
++- }
++-
++- _mm_store_ps(tempBuffer,accumulator);
++-
++- returnValue = tempBuffer[0];
++- returnValue += tempBuffer[1];
++- returnValue += tempBuffer[2];
++- returnValue += tempBuffer[3];
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- returnValue += (*aPtr++);
++- }
++- *result = returnValue;
+++ float returnValue = 0;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* aPtr = inputBuffer;
+++ __VOLK_ATTR_ALIGNED(16) float tempBuffer[4];
+++
+++ __m128 accumulator = _mm_setzero_ps();
+++ __m128 aVal = _mm_setzero_ps();
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
+++ accumulator = _mm_add_ps(accumulator, aVal);
+++ aPtr += 4;
+++ }
+++
+++ _mm_store_ps(tempBuffer, accumulator);
+++
+++ returnValue = tempBuffer[0];
+++ returnValue += tempBuffer[1];
+++ returnValue += tempBuffer[2];
+++ returnValue += tempBuffer[3];
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ returnValue += (*aPtr++);
+++ }
+++ *result = returnValue;
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -191,52 +194,54 @@ volk_32f_accumulator_s32f_a_sse(float* result, const float* inputBuffer, unsigne
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_accumulator_s32f_u_sse(float* result, const float* inputBuffer, unsigned int num_points)
+++static inline void volk_32f_accumulator_s32f_u_sse(float* result,
+++ const float* inputBuffer,
+++ unsigned int num_points)
++ {
++- float returnValue = 0;
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* aPtr = inputBuffer;
++- __VOLK_ATTR_ALIGNED(16) float tempBuffer[4];
++-
++- __m128 accumulator = _mm_setzero_ps();
++- __m128 aVal = _mm_setzero_ps();
++-
++- for(;number < quarterPoints; number++){
++- aVal = _mm_load_ps(aPtr);
++- accumulator = _mm_add_ps(accumulator, aVal);
++- aPtr += 4;
++- }
++-
++- _mm_store_ps(tempBuffer,accumulator);
++-
++- returnValue = tempBuffer[0];
++- returnValue += tempBuffer[1];
++- returnValue += tempBuffer[2];
++- returnValue += tempBuffer[3];
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- returnValue += (*aPtr++);
++- }
++- *result = returnValue;
+++ float returnValue = 0;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* aPtr = inputBuffer;
+++ __VOLK_ATTR_ALIGNED(16) float tempBuffer[4];
+++
+++ __m128 accumulator = _mm_setzero_ps();
+++ __m128 aVal = _mm_setzero_ps();
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
+++ accumulator = _mm_add_ps(accumulator, aVal);
+++ aPtr += 4;
+++ }
+++
+++ _mm_store_ps(tempBuffer, accumulator);
+++
+++ returnValue = tempBuffer[0];
+++ returnValue += tempBuffer[1];
+++ returnValue += tempBuffer[2];
+++ returnValue += tempBuffer[3];
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ returnValue += (*aPtr++);
+++ }
+++ *result = returnValue;
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void
++-volk_32f_accumulator_s32f_generic(float* result, const float* inputBuffer, unsigned int num_points)
+++static inline void volk_32f_accumulator_s32f_generic(float* result,
+++ const float* inputBuffer,
+++ unsigned int num_points)
++ {
++- const float* aPtr = inputBuffer;
++- unsigned int number = 0;
++- float returnValue = 0;
++-
++- for(;number < num_points; number++){
++- returnValue += (*aPtr++);
++- }
++- *result = returnValue;
+++ const float* aPtr = inputBuffer;
+++ unsigned int number = 0;
+++ float returnValue = 0;
+++
+++ for (; number < num_points; number++) {
+++ returnValue += (*aPtr++);
+++ }
+++ *result = returnValue;
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32f_acos_32f.h b/kernels/volk/volk_32f_acos_32f.h
++index 5c14c2f..92918ca 100644
++--- a/kernels/volk/volk_32f_acos_32f.h
+++++ b/kernels/volk/volk_32f_acos_32f.h
++@@ -67,11 +67,12 @@
++ * \endcode
++ */
++
++-#include <stdio.h>
++-#include <math.h>
++ #include <inttypes.h>
+++#include <math.h>
+++#include <stdio.h>
++
++-/* This is the number of terms of Taylor series to evaluate, increase this for more accuracy*/
+++/* This is the number of terms of Taylor series to evaluate, increase this for more
+++ * accuracy*/
++ #define ACOS_TERMS 2
++
++ #ifndef INCLUDED_volk_32f_acos_32f_a_H
++@@ -80,62 +81,68 @@
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_acos_32f_a_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_acos_32f_a_avx2_fma(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- int i, j;
++-
++- __m256 aVal, d, pi, pio2, x, y, z, arccosine;
++- __m256 fzeroes, fones, ftwos, ffours, condition;
++-
++- pi = _mm256_set1_ps(3.14159265358979323846);
++- pio2 = _mm256_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm256_setzero_ps();
++- fones = _mm256_set1_ps(1.0);
++- ftwos = _mm256_set1_ps(2.0);
++- ffours = _mm256_set1_ps(4.0);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- d = aVal;
++- aVal = _mm256_div_ps(_mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal), _mm256_sub_ps(fones, aVal))), aVal);
++- z = aVal;
++- condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
++- z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
++- condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
++- x = _mm256_add_ps(z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++)
++- x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_fmadd_ps(x, x,fones)));
++- x = _mm256_div_ps(fones, x);
++- y = fzeroes;
++- for(j = ACOS_TERMS - 1; j >=0 ; j--)
++- y = _mm256_fmadd_ps(y, _mm256_mul_ps(x, x), _mm256_set1_ps(pow(-1,j)/(2*j+1)));
++-
++- y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
++- condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
++-
++- y = _mm256_add_ps(y, _mm256_and_ps(_mm256_fnmadd_ps(y, ftwos, pio2), condition));
++- arccosine = y;
++- condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
++- arccosine = _mm256_sub_ps(arccosine, _mm256_and_ps(_mm256_mul_ps(arccosine, ftwos), condition));
++- condition = _mm256_cmp_ps(d, fzeroes, _CMP_LT_OS);
++- arccosine = _mm256_add_ps(arccosine, _mm256_and_ps(pi, condition));
++-
++- _mm256_store_ps(bPtr, arccosine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = acos(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ int i, j;
+++
+++ __m256 aVal, d, pi, pio2, x, y, z, arccosine;
+++ __m256 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pi = _mm256_set1_ps(3.14159265358979323846);
+++ pio2 = _mm256_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm256_setzero_ps();
+++ fones = _mm256_set1_ps(1.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ ffours = _mm256_set1_ps(4.0);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ d = aVal;
+++ aVal = _mm256_div_ps(_mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal),
+++ _mm256_sub_ps(fones, aVal))),
+++ aVal);
+++ z = aVal;
+++ condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
+++ z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
+++ x = _mm256_add_ps(
+++ z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++)
+++ x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_fmadd_ps(x, x, fones)));
+++ x = _mm256_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = ACOS_TERMS - 1; j >= 0; j--)
+++ y = _mm256_fmadd_ps(
+++ y, _mm256_mul_ps(x, x), _mm256_set1_ps(pow(-1, j) / (2 * j + 1)));
+++
+++ y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
+++
+++ y = _mm256_add_ps(y, _mm256_and_ps(_mm256_fnmadd_ps(y, ftwos, pio2), condition));
+++ arccosine = y;
+++ condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
+++ arccosine = _mm256_sub_ps(
+++ arccosine, _mm256_and_ps(_mm256_mul_ps(arccosine, ftwos), condition));
+++ condition = _mm256_cmp_ps(d, fzeroes, _CMP_LT_OS);
+++ arccosine = _mm256_add_ps(arccosine, _mm256_and_ps(pi, condition));
+++
+++ _mm256_store_ps(bPtr, arccosine);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = acos(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for aligned */
++@@ -147,59 +154,66 @@ volk_32f_acos_32f_a_avx2_fma(float* bVector, const float* aVector, unsigned int
++ static inline void
++ volk_32f_acos_32f_a_avx(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- int i, j;
++-
++- __m256 aVal, d, pi, pio2, x, y, z, arccosine;
++- __m256 fzeroes, fones, ftwos, ffours, condition;
++-
++- pi = _mm256_set1_ps(3.14159265358979323846);
++- pio2 = _mm256_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm256_setzero_ps();
++- fones = _mm256_set1_ps(1.0);
++- ftwos = _mm256_set1_ps(2.0);
++- ffours = _mm256_set1_ps(4.0);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- d = aVal;
++- aVal = _mm256_div_ps(_mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal), _mm256_sub_ps(fones, aVal))), aVal);
++- z = aVal;
++- condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
++- z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
++- condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
++- x = _mm256_add_ps(z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++)
++- x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_add_ps(fones, _mm256_mul_ps(x, x))));
++- x = _mm256_div_ps(fones, x);
++- y = fzeroes;
++- for(j = ACOS_TERMS - 1; j >=0 ; j--)
++- y = _mm256_add_ps(_mm256_mul_ps(y, _mm256_mul_ps(x, x)), _mm256_set1_ps(pow(-1,j)/(2*j+1)));
++-
++- y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
++- condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
++-
++- y = _mm256_add_ps(y, _mm256_and_ps(_mm256_sub_ps(pio2, _mm256_mul_ps(y, ftwos)), condition));
++- arccosine = y;
++- condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
++- arccosine = _mm256_sub_ps(arccosine, _mm256_and_ps(_mm256_mul_ps(arccosine, ftwos), condition));
++- condition = _mm256_cmp_ps(d, fzeroes, _CMP_LT_OS);
++- arccosine = _mm256_add_ps(arccosine, _mm256_and_ps(pi, condition));
++-
++- _mm256_store_ps(bPtr, arccosine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = acos(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ int i, j;
+++
+++ __m256 aVal, d, pi, pio2, x, y, z, arccosine;
+++ __m256 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pi = _mm256_set1_ps(3.14159265358979323846);
+++ pio2 = _mm256_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm256_setzero_ps();
+++ fones = _mm256_set1_ps(1.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ ffours = _mm256_set1_ps(4.0);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ d = aVal;
+++ aVal = _mm256_div_ps(_mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal),
+++ _mm256_sub_ps(fones, aVal))),
+++ aVal);
+++ z = aVal;
+++ condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
+++ z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
+++ x = _mm256_add_ps(
+++ z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++)
+++ x = _mm256_add_ps(x,
+++ _mm256_sqrt_ps(_mm256_add_ps(fones, _mm256_mul_ps(x, x))));
+++ x = _mm256_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = ACOS_TERMS - 1; j >= 0; j--)
+++ y = _mm256_add_ps(_mm256_mul_ps(y, _mm256_mul_ps(x, x)),
+++ _mm256_set1_ps(pow(-1, j) / (2 * j + 1)));
+++
+++ y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
+++
+++ y = _mm256_add_ps(
+++ y, _mm256_and_ps(_mm256_sub_ps(pio2, _mm256_mul_ps(y, ftwos)), condition));
+++ arccosine = y;
+++ condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
+++ arccosine = _mm256_sub_ps(
+++ arccosine, _mm256_and_ps(_mm256_mul_ps(arccosine, ftwos), condition));
+++ condition = _mm256_cmp_ps(d, fzeroes, _CMP_LT_OS);
+++ arccosine = _mm256_add_ps(arccosine, _mm256_and_ps(pi, condition));
+++
+++ _mm256_store_ps(bPtr, arccosine);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = acos(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 for aligned */
++@@ -210,59 +224,63 @@ volk_32f_acos_32f_a_avx(float* bVector, const float* aVector, unsigned int num_p
++ static inline void
++ volk_32f_acos_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int quarterPoints = num_points / 4;
++- int i, j;
++-
++- __m128 aVal, d, pi, pio2, x, y, z, arccosine;
++- __m128 fzeroes, fones, ftwos, ffours, condition;
++-
++- pi = _mm_set1_ps(3.14159265358979323846);
++- pio2 = _mm_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm_setzero_ps();
++- fones = _mm_set1_ps(1.0);
++- ftwos = _mm_set1_ps(2.0);
++- ffours = _mm_set1_ps(4.0);
++-
++- for(;number < quarterPoints; number++){
++- aVal = _mm_load_ps(aPtr);
++- d = aVal;
++- aVal = _mm_div_ps(_mm_sqrt_ps(_mm_mul_ps(_mm_add_ps(fones, aVal), _mm_sub_ps(fones, aVal))), aVal);
++- z = aVal;
++- condition = _mm_cmplt_ps(z, fzeroes);
++- z = _mm_sub_ps(z, _mm_and_ps(_mm_mul_ps(z, ftwos), condition));
++- condition = _mm_cmplt_ps(z, fones);
++- x = _mm_add_ps(z, _mm_and_ps(_mm_sub_ps(_mm_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++)
++- x = _mm_add_ps(x, _mm_sqrt_ps(_mm_add_ps(fones, _mm_mul_ps(x, x))));
++- x = _mm_div_ps(fones, x);
++- y = fzeroes;
++- for(j = ACOS_TERMS - 1; j >=0 ; j--)
++- y = _mm_add_ps(_mm_mul_ps(y, _mm_mul_ps(x, x)), _mm_set1_ps(pow(-1,j)/(2*j+1)));
++-
++- y = _mm_mul_ps(y, _mm_mul_ps(x, ffours));
++- condition = _mm_cmpgt_ps(z, fones);
++-
++- y = _mm_add_ps(y, _mm_and_ps(_mm_sub_ps(pio2, _mm_mul_ps(y, ftwos)), condition));
++- arccosine = y;
++- condition = _mm_cmplt_ps(aVal, fzeroes);
++- arccosine = _mm_sub_ps(arccosine, _mm_and_ps(_mm_mul_ps(arccosine, ftwos), condition));
++- condition = _mm_cmplt_ps(d, fzeroes);
++- arccosine = _mm_add_ps(arccosine, _mm_and_ps(pi, condition));
++-
++- _mm_store_ps(bPtr, arccosine);
++- aPtr += 4;
++- bPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *bPtr++ = acosf(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int quarterPoints = num_points / 4;
+++ int i, j;
+++
+++ __m128 aVal, d, pi, pio2, x, y, z, arccosine;
+++ __m128 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pi = _mm_set1_ps(3.14159265358979323846);
+++ pio2 = _mm_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm_setzero_ps();
+++ fones = _mm_set1_ps(1.0);
+++ ftwos = _mm_set1_ps(2.0);
+++ ffours = _mm_set1_ps(4.0);
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
+++ d = aVal;
+++ aVal = _mm_div_ps(
+++ _mm_sqrt_ps(_mm_mul_ps(_mm_add_ps(fones, aVal), _mm_sub_ps(fones, aVal))),
+++ aVal);
+++ z = aVal;
+++ condition = _mm_cmplt_ps(z, fzeroes);
+++ z = _mm_sub_ps(z, _mm_and_ps(_mm_mul_ps(z, ftwos), condition));
+++ condition = _mm_cmplt_ps(z, fones);
+++ x = _mm_add_ps(z, _mm_and_ps(_mm_sub_ps(_mm_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++)
+++ x = _mm_add_ps(x, _mm_sqrt_ps(_mm_add_ps(fones, _mm_mul_ps(x, x))));
+++ x = _mm_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = ACOS_TERMS - 1; j >= 0; j--)
+++ y = _mm_add_ps(_mm_mul_ps(y, _mm_mul_ps(x, x)),
+++ _mm_set1_ps(pow(-1, j) / (2 * j + 1)));
+++
+++ y = _mm_mul_ps(y, _mm_mul_ps(x, ffours));
+++ condition = _mm_cmpgt_ps(z, fones);
+++
+++ y = _mm_add_ps(y, _mm_and_ps(_mm_sub_ps(pio2, _mm_mul_ps(y, ftwos)), condition));
+++ arccosine = y;
+++ condition = _mm_cmplt_ps(aVal, fzeroes);
+++ arccosine =
+++ _mm_sub_ps(arccosine, _mm_and_ps(_mm_mul_ps(arccosine, ftwos), condition));
+++ condition = _mm_cmplt_ps(d, fzeroes);
+++ arccosine = _mm_add_ps(arccosine, _mm_and_ps(pi, condition));
+++
+++ _mm_store_ps(bPtr, arccosine);
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = acosf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for aligned */
++@@ -276,62 +294,68 @@ volk_32f_acos_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int nu
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_acos_32f_u_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_acos_32f_u_avx2_fma(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- int i, j;
++-
++- __m256 aVal, d, pi, pio2, x, y, z, arccosine;
++- __m256 fzeroes, fones, ftwos, ffours, condition;
++-
++- pi = _mm256_set1_ps(3.14159265358979323846);
++- pio2 = _mm256_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm256_setzero_ps();
++- fones = _mm256_set1_ps(1.0);
++- ftwos = _mm256_set1_ps(2.0);
++- ffours = _mm256_set1_ps(4.0);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- d = aVal;
++- aVal = _mm256_div_ps(_mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal), _mm256_sub_ps(fones, aVal))), aVal);
++- z = aVal;
++- condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
++- z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
++- condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
++- x = _mm256_add_ps(z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++)
++- x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_fmadd_ps(x, x,fones)));
++- x = _mm256_div_ps(fones, x);
++- y = fzeroes;
++- for(j = ACOS_TERMS - 1; j >=0 ; j--)
++- y = _mm256_fmadd_ps(y, _mm256_mul_ps(x, x), _mm256_set1_ps(pow(-1,j)/(2*j+1)));
++-
++- y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
++- condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
++-
++- y = _mm256_add_ps(y, _mm256_and_ps(_mm256_fnmadd_ps(y, ftwos, pio2), condition));
++- arccosine = y;
++- condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
++- arccosine = _mm256_sub_ps(arccosine, _mm256_and_ps(_mm256_mul_ps(arccosine, ftwos), condition));
++- condition = _mm256_cmp_ps(d, fzeroes, _CMP_LT_OS);
++- arccosine = _mm256_add_ps(arccosine, _mm256_and_ps(pi, condition));
++-
++- _mm256_storeu_ps(bPtr, arccosine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = acos(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ int i, j;
+++
+++ __m256 aVal, d, pi, pio2, x, y, z, arccosine;
+++ __m256 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pi = _mm256_set1_ps(3.14159265358979323846);
+++ pio2 = _mm256_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm256_setzero_ps();
+++ fones = _mm256_set1_ps(1.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ ffours = _mm256_set1_ps(4.0);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ d = aVal;
+++ aVal = _mm256_div_ps(_mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal),
+++ _mm256_sub_ps(fones, aVal))),
+++ aVal);
+++ z = aVal;
+++ condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
+++ z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
+++ x = _mm256_add_ps(
+++ z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++)
+++ x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_fmadd_ps(x, x, fones)));
+++ x = _mm256_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = ACOS_TERMS - 1; j >= 0; j--)
+++ y = _mm256_fmadd_ps(
+++ y, _mm256_mul_ps(x, x), _mm256_set1_ps(pow(-1, j) / (2 * j + 1)));
+++
+++ y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
+++
+++ y = _mm256_add_ps(y, _mm256_and_ps(_mm256_fnmadd_ps(y, ftwos, pio2), condition));
+++ arccosine = y;
+++ condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
+++ arccosine = _mm256_sub_ps(
+++ arccosine, _mm256_and_ps(_mm256_mul_ps(arccosine, ftwos), condition));
+++ condition = _mm256_cmp_ps(d, fzeroes, _CMP_LT_OS);
+++ arccosine = _mm256_add_ps(arccosine, _mm256_and_ps(pi, condition));
+++
+++ _mm256_storeu_ps(bPtr, arccosine);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = acos(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for unaligned */
++@@ -343,59 +367,66 @@ volk_32f_acos_32f_u_avx2_fma(float* bVector, const float* aVector, unsigned int
++ static inline void
++ volk_32f_acos_32f_u_avx(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- int i, j;
++-
++- __m256 aVal, d, pi, pio2, x, y, z, arccosine;
++- __m256 fzeroes, fones, ftwos, ffours, condition;
++-
++- pi = _mm256_set1_ps(3.14159265358979323846);
++- pio2 = _mm256_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm256_setzero_ps();
++- fones = _mm256_set1_ps(1.0);
++- ftwos = _mm256_set1_ps(2.0);
++- ffours = _mm256_set1_ps(4.0);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- d = aVal;
++- aVal = _mm256_div_ps(_mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal), _mm256_sub_ps(fones, aVal))), aVal);
++- z = aVal;
++- condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
++- z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
++- condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
++- x = _mm256_add_ps(z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++)
++- x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_add_ps(fones, _mm256_mul_ps(x, x))));
++- x = _mm256_div_ps(fones, x);
++- y = fzeroes;
++- for(j = ACOS_TERMS - 1; j >=0 ; j--)
++- y = _mm256_add_ps(_mm256_mul_ps(y, _mm256_mul_ps(x, x)), _mm256_set1_ps(pow(-1,j)/(2*j+1)));
++-
++- y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
++- condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
++-
++- y = _mm256_add_ps(y, _mm256_and_ps(_mm256_sub_ps(pio2, _mm256_mul_ps(y, ftwos)), condition));
++- arccosine = y;
++- condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
++- arccosine = _mm256_sub_ps(arccosine, _mm256_and_ps(_mm256_mul_ps(arccosine, ftwos), condition));
++- condition = _mm256_cmp_ps(d, fzeroes, _CMP_LT_OS);
++- arccosine = _mm256_add_ps(arccosine, _mm256_and_ps(pi, condition));
++-
++- _mm256_storeu_ps(bPtr, arccosine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = acos(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ int i, j;
+++
+++ __m256 aVal, d, pi, pio2, x, y, z, arccosine;
+++ __m256 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pi = _mm256_set1_ps(3.14159265358979323846);
+++ pio2 = _mm256_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm256_setzero_ps();
+++ fones = _mm256_set1_ps(1.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ ffours = _mm256_set1_ps(4.0);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ d = aVal;
+++ aVal = _mm256_div_ps(_mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal),
+++ _mm256_sub_ps(fones, aVal))),
+++ aVal);
+++ z = aVal;
+++ condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
+++ z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
+++ x = _mm256_add_ps(
+++ z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++)
+++ x = _mm256_add_ps(x,
+++ _mm256_sqrt_ps(_mm256_add_ps(fones, _mm256_mul_ps(x, x))));
+++ x = _mm256_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = ACOS_TERMS - 1; j >= 0; j--)
+++ y = _mm256_add_ps(_mm256_mul_ps(y, _mm256_mul_ps(x, x)),
+++ _mm256_set1_ps(pow(-1, j) / (2 * j + 1)));
+++
+++ y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
+++
+++ y = _mm256_add_ps(
+++ y, _mm256_and_ps(_mm256_sub_ps(pio2, _mm256_mul_ps(y, ftwos)), condition));
+++ arccosine = y;
+++ condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
+++ arccosine = _mm256_sub_ps(
+++ arccosine, _mm256_and_ps(_mm256_mul_ps(arccosine, ftwos), condition));
+++ condition = _mm256_cmp_ps(d, fzeroes, _CMP_LT_OS);
+++ arccosine = _mm256_add_ps(arccosine, _mm256_and_ps(pi, condition));
+++
+++ _mm256_storeu_ps(bPtr, arccosine);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = acos(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 for unaligned */
++@@ -406,60 +437,64 @@ volk_32f_acos_32f_u_avx(float* bVector, const float* aVector, unsigned int num_p
++ static inline void
++ volk_32f_acos_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int quarterPoints = num_points / 4;
++- int i, j;
++-
++- __m128 aVal, d, pi, pio2, x, y, z, arccosine;
++- __m128 fzeroes, fones, ftwos, ffours, condition;
++-
++- pi = _mm_set1_ps(3.14159265358979323846);
++- pio2 = _mm_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm_setzero_ps();
++- fones = _mm_set1_ps(1.0);
++- ftwos = _mm_set1_ps(2.0);
++- ffours = _mm_set1_ps(4.0);
++-
++- for(;number < quarterPoints; number++){
++- aVal = _mm_loadu_ps(aPtr);
++- d = aVal;
++- aVal = _mm_div_ps(_mm_sqrt_ps(_mm_mul_ps(_mm_add_ps(fones, aVal), _mm_sub_ps(fones, aVal))), aVal);
++- z = aVal;
++- condition = _mm_cmplt_ps(z, fzeroes);
++- z = _mm_sub_ps(z, _mm_and_ps(_mm_mul_ps(z, ftwos), condition));
++- condition = _mm_cmplt_ps(z, fones);
++- x = _mm_add_ps(z, _mm_and_ps(_mm_sub_ps(_mm_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++)
++- x = _mm_add_ps(x, _mm_sqrt_ps(_mm_add_ps(fones, _mm_mul_ps(x, x))));
++- x = _mm_div_ps(fones, x);
++- y = fzeroes;
++-
++- for(j = ACOS_TERMS - 1; j >=0 ; j--)
++- y = _mm_add_ps(_mm_mul_ps(y, _mm_mul_ps(x, x)), _mm_set1_ps(pow(-1,j)/(2*j+1)));
++-
++- y = _mm_mul_ps(y, _mm_mul_ps(x, ffours));
++- condition = _mm_cmpgt_ps(z, fones);
++-
++- y = _mm_add_ps(y, _mm_and_ps(_mm_sub_ps(pio2, _mm_mul_ps(y, ftwos)), condition));
++- arccosine = y;
++- condition = _mm_cmplt_ps(aVal, fzeroes);
++- arccosine = _mm_sub_ps(arccosine, _mm_and_ps(_mm_mul_ps(arccosine, ftwos), condition));
++- condition = _mm_cmplt_ps(d, fzeroes);
++- arccosine = _mm_add_ps(arccosine, _mm_and_ps(pi, condition));
++-
++- _mm_storeu_ps(bPtr, arccosine);
++- aPtr += 4;
++- bPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *bPtr++ = acosf(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int quarterPoints = num_points / 4;
+++ int i, j;
+++
+++ __m128 aVal, d, pi, pio2, x, y, z, arccosine;
+++ __m128 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pi = _mm_set1_ps(3.14159265358979323846);
+++ pio2 = _mm_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm_setzero_ps();
+++ fones = _mm_set1_ps(1.0);
+++ ftwos = _mm_set1_ps(2.0);
+++ ffours = _mm_set1_ps(4.0);
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_loadu_ps(aPtr);
+++ d = aVal;
+++ aVal = _mm_div_ps(
+++ _mm_sqrt_ps(_mm_mul_ps(_mm_add_ps(fones, aVal), _mm_sub_ps(fones, aVal))),
+++ aVal);
+++ z = aVal;
+++ condition = _mm_cmplt_ps(z, fzeroes);
+++ z = _mm_sub_ps(z, _mm_and_ps(_mm_mul_ps(z, ftwos), condition));
+++ condition = _mm_cmplt_ps(z, fones);
+++ x = _mm_add_ps(z, _mm_and_ps(_mm_sub_ps(_mm_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++)
+++ x = _mm_add_ps(x, _mm_sqrt_ps(_mm_add_ps(fones, _mm_mul_ps(x, x))));
+++ x = _mm_div_ps(fones, x);
+++ y = fzeroes;
+++
+++ for (j = ACOS_TERMS - 1; j >= 0; j--)
+++ y = _mm_add_ps(_mm_mul_ps(y, _mm_mul_ps(x, x)),
+++ _mm_set1_ps(pow(-1, j) / (2 * j + 1)));
+++
+++ y = _mm_mul_ps(y, _mm_mul_ps(x, ffours));
+++ condition = _mm_cmpgt_ps(z, fones);
+++
+++ y = _mm_add_ps(y, _mm_and_ps(_mm_sub_ps(pio2, _mm_mul_ps(y, ftwos)), condition));
+++ arccosine = y;
+++ condition = _mm_cmplt_ps(aVal, fzeroes);
+++ arccosine =
+++ _mm_sub_ps(arccosine, _mm_and_ps(_mm_mul_ps(arccosine, ftwos), condition));
+++ condition = _mm_cmplt_ps(d, fzeroes);
+++ arccosine = _mm_add_ps(arccosine, _mm_and_ps(pi, condition));
+++
+++ _mm_storeu_ps(bPtr, arccosine);
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = acosf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for aligned */
++@@ -469,14 +504,13 @@ volk_32f_acos_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int nu
++ static inline void
++ volk_32f_acos_32f_generic(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *bPtr++ = acosf(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
+++ for (number = 0; number < num_points; number++) {
+++ *bPtr++ = acosf(*aPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32f_asin_32f.h b/kernels/volk/volk_32f_asin_32f.h
++index 864cfcf..946d382 100644
++--- a/kernels/volk/volk_32f_asin_32f.h
+++++ b/kernels/volk/volk_32f_asin_32f.h
++@@ -67,11 +67,12 @@
++ * \endcode
++ */
++
++-#include <stdio.h>
++-#include <math.h>
++ #include <inttypes.h>
+++#include <math.h>
+++#include <stdio.h>
++
++-/* This is the number of terms of Taylor series to evaluate, increase this for more accuracy*/
+++/* This is the number of terms of Taylor series to evaluate, increase this for more
+++ * accuracy*/
++ #define ASIN_TERMS 2
++
++ #ifndef INCLUDED_volk_32f_asin_32f_a_H
++@@ -80,60 +81,66 @@
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_asin_32f_a_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_asin_32f_a_avx2_fma(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- int i, j;
++-
++- __m256 aVal, pio2, x, y, z, arcsine;
++- __m256 fzeroes, fones, ftwos, ffours, condition;
++-
++- pio2 = _mm256_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm256_setzero_ps();
++- fones = _mm256_set1_ps(1.0);
++- ftwos = _mm256_set1_ps(2.0);
++- ffours = _mm256_set1_ps(4.0);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- aVal = _mm256_div_ps(aVal, _mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal), _mm256_sub_ps(fones, aVal))));
++- z = aVal;
++- condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
++- z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
++- condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
++- x = _mm256_add_ps(z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++){
++- x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_fmadd_ps(x,x,fones)));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ int i, j;
+++
+++ __m256 aVal, pio2, x, y, z, arcsine;
+++ __m256 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pio2 = _mm256_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm256_setzero_ps();
+++ fones = _mm256_set1_ps(1.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ ffours = _mm256_set1_ps(4.0);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ aVal = _mm256_div_ps(aVal,
+++ _mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal),
+++ _mm256_sub_ps(fones, aVal))));
+++ z = aVal;
+++ condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
+++ z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
+++ x = _mm256_add_ps(
+++ z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++) {
+++ x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_fmadd_ps(x, x, fones)));
+++ }
+++ x = _mm256_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = ASIN_TERMS - 1; j >= 0; j--) {
+++ y = _mm256_fmadd_ps(
+++ y, _mm256_mul_ps(x, x), _mm256_set1_ps(pow(-1, j) / (2 * j + 1)));
+++ }
+++
+++ y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
+++
+++ y = _mm256_add_ps(y, _mm256_and_ps(_mm256_fnmadd_ps(y, ftwos, pio2), condition));
+++ arcsine = y;
+++ condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
+++ arcsine = _mm256_sub_ps(arcsine,
+++ _mm256_and_ps(_mm256_mul_ps(arcsine, ftwos), condition));
+++
+++ _mm256_store_ps(bPtr, arcsine);
+++ aPtr += 8;
+++ bPtr += 8;
++ }
++- x = _mm256_div_ps(fones, x);
++- y = fzeroes;
++- for(j = ASIN_TERMS - 1; j >=0 ; j--){
++- y = _mm256_fmadd_ps(y, _mm256_mul_ps(x, x), _mm256_set1_ps(pow(-1,j)/(2*j+1)));
++- }
++-
++- y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
++- condition = _mm256_cmp_ps(z, fones,_CMP_GT_OS);
++-
++- y = _mm256_add_ps(y, _mm256_and_ps(_mm256_fnmadd_ps(y,ftwos,pio2), condition));
++- arcsine = y;
++- condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
++- arcsine = _mm256_sub_ps(arcsine, _mm256_and_ps(_mm256_mul_ps(arcsine, ftwos), condition));
++
++- _mm256_store_ps(bPtr, arcsine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = asin(*aPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = asin(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for aligned */
++@@ -145,57 +152,64 @@ volk_32f_asin_32f_a_avx2_fma(float* bVector, const float* aVector, unsigned int
++ static inline void
++ volk_32f_asin_32f_a_avx(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- int i, j;
++-
++- __m256 aVal, pio2, x, y, z, arcsine;
++- __m256 fzeroes, fones, ftwos, ffours, condition;
++-
++- pio2 = _mm256_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm256_setzero_ps();
++- fones = _mm256_set1_ps(1.0);
++- ftwos = _mm256_set1_ps(2.0);
++- ffours = _mm256_set1_ps(4.0);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- aVal = _mm256_div_ps(aVal, _mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal), _mm256_sub_ps(fones, aVal))));
++- z = aVal;
++- condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
++- z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
++- condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
++- x = _mm256_add_ps(z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++){
++- x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_add_ps(fones, _mm256_mul_ps(x, x))));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ int i, j;
+++
+++ __m256 aVal, pio2, x, y, z, arcsine;
+++ __m256 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pio2 = _mm256_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm256_setzero_ps();
+++ fones = _mm256_set1_ps(1.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ ffours = _mm256_set1_ps(4.0);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ aVal = _mm256_div_ps(aVal,
+++ _mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal),
+++ _mm256_sub_ps(fones, aVal))));
+++ z = aVal;
+++ condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
+++ z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
+++ x = _mm256_add_ps(
+++ z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++) {
+++ x = _mm256_add_ps(x,
+++ _mm256_sqrt_ps(_mm256_add_ps(fones, _mm256_mul_ps(x, x))));
+++ }
+++ x = _mm256_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = ASIN_TERMS - 1; j >= 0; j--) {
+++ y = _mm256_add_ps(_mm256_mul_ps(y, _mm256_mul_ps(x, x)),
+++ _mm256_set1_ps(pow(-1, j) / (2 * j + 1)));
+++ }
+++
+++ y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
+++
+++ y = _mm256_add_ps(
+++ y, _mm256_and_ps(_mm256_sub_ps(pio2, _mm256_mul_ps(y, ftwos)), condition));
+++ arcsine = y;
+++ condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
+++ arcsine = _mm256_sub_ps(arcsine,
+++ _mm256_and_ps(_mm256_mul_ps(arcsine, ftwos), condition));
+++
+++ _mm256_store_ps(bPtr, arcsine);
+++ aPtr += 8;
+++ bPtr += 8;
++ }
++- x = _mm256_div_ps(fones, x);
++- y = fzeroes;
++- for(j = ASIN_TERMS - 1; j >=0 ; j--){
++- y = _mm256_add_ps(_mm256_mul_ps(y, _mm256_mul_ps(x, x)), _mm256_set1_ps(pow(-1,j)/(2*j+1)));
++- }
++-
++- y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
++- condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
++-
++- y = _mm256_add_ps(y, _mm256_and_ps(_mm256_sub_ps(pio2, _mm256_mul_ps(y, ftwos)), condition));
++- arcsine = y;
++- condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
++- arcsine = _mm256_sub_ps(arcsine, _mm256_and_ps(_mm256_mul_ps(arcsine, ftwos), condition));
++
++- _mm256_store_ps(bPtr, arcsine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = asin(*aPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = asin(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX for aligned */
++@@ -206,57 +220,60 @@ volk_32f_asin_32f_a_avx(float* bVector, const float* aVector, unsigned int num_p
++ static inline void
++ volk_32f_asin_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int quarterPoints = num_points / 4;
++- int i, j;
++-
++- __m128 aVal, pio2, x, y, z, arcsine;
++- __m128 fzeroes, fones, ftwos, ffours, condition;
++-
++- pio2 = _mm_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm_setzero_ps();
++- fones = _mm_set1_ps(1.0);
++- ftwos = _mm_set1_ps(2.0);
++- ffours = _mm_set1_ps(4.0);
++-
++- for(;number < quarterPoints; number++){
++- aVal = _mm_load_ps(aPtr);
++- aVal = _mm_div_ps(aVal, _mm_sqrt_ps(_mm_mul_ps(_mm_add_ps(fones, aVal), _mm_sub_ps(fones, aVal))));
++- z = aVal;
++- condition = _mm_cmplt_ps(z, fzeroes);
++- z = _mm_sub_ps(z, _mm_and_ps(_mm_mul_ps(z, ftwos), condition));
++- condition = _mm_cmplt_ps(z, fones);
++- x = _mm_add_ps(z, _mm_and_ps(_mm_sub_ps(_mm_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++){
++- x = _mm_add_ps(x, _mm_sqrt_ps(_mm_add_ps(fones, _mm_mul_ps(x, x))));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int quarterPoints = num_points / 4;
+++ int i, j;
+++
+++ __m128 aVal, pio2, x, y, z, arcsine;
+++ __m128 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pio2 = _mm_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm_setzero_ps();
+++ fones = _mm_set1_ps(1.0);
+++ ftwos = _mm_set1_ps(2.0);
+++ ffours = _mm_set1_ps(4.0);
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
+++ aVal = _mm_div_ps(
+++ aVal,
+++ _mm_sqrt_ps(_mm_mul_ps(_mm_add_ps(fones, aVal), _mm_sub_ps(fones, aVal))));
+++ z = aVal;
+++ condition = _mm_cmplt_ps(z, fzeroes);
+++ z = _mm_sub_ps(z, _mm_and_ps(_mm_mul_ps(z, ftwos), condition));
+++ condition = _mm_cmplt_ps(z, fones);
+++ x = _mm_add_ps(z, _mm_and_ps(_mm_sub_ps(_mm_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++) {
+++ x = _mm_add_ps(x, _mm_sqrt_ps(_mm_add_ps(fones, _mm_mul_ps(x, x))));
+++ }
+++ x = _mm_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = ASIN_TERMS - 1; j >= 0; j--) {
+++ y = _mm_add_ps(_mm_mul_ps(y, _mm_mul_ps(x, x)),
+++ _mm_set1_ps(pow(-1, j) / (2 * j + 1)));
+++ }
+++
+++ y = _mm_mul_ps(y, _mm_mul_ps(x, ffours));
+++ condition = _mm_cmpgt_ps(z, fones);
+++
+++ y = _mm_add_ps(y, _mm_and_ps(_mm_sub_ps(pio2, _mm_mul_ps(y, ftwos)), condition));
+++ arcsine = y;
+++ condition = _mm_cmplt_ps(aVal, fzeroes);
+++ arcsine = _mm_sub_ps(arcsine, _mm_and_ps(_mm_mul_ps(arcsine, ftwos), condition));
+++
+++ _mm_store_ps(bPtr, arcsine);
+++ aPtr += 4;
+++ bPtr += 4;
++ }
++- x = _mm_div_ps(fones, x);
++- y = fzeroes;
++- for(j = ASIN_TERMS - 1; j >=0 ; j--){
++- y = _mm_add_ps(_mm_mul_ps(y, _mm_mul_ps(x, x)), _mm_set1_ps(pow(-1,j)/(2*j+1)));
++- }
++-
++- y = _mm_mul_ps(y, _mm_mul_ps(x, ffours));
++- condition = _mm_cmpgt_ps(z, fones);
++-
++- y = _mm_add_ps(y, _mm_and_ps(_mm_sub_ps(pio2, _mm_mul_ps(y, ftwos)), condition));
++- arcsine = y;
++- condition = _mm_cmplt_ps(aVal, fzeroes);
++- arcsine = _mm_sub_ps(arcsine, _mm_and_ps(_mm_mul_ps(arcsine, ftwos), condition));
++-
++- _mm_store_ps(bPtr, arcsine);
++- aPtr += 4;
++- bPtr += 4;
++- }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *bPtr++ = asinf(*aPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = asinf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for aligned */
++@@ -269,60 +286,66 @@ volk_32f_asin_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int nu
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_asin_32f_u_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_asin_32f_u_avx2_fma(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- int i, j;
++-
++- __m256 aVal, pio2, x, y, z, arcsine;
++- __m256 fzeroes, fones, ftwos, ffours, condition;
++-
++- pio2 = _mm256_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm256_setzero_ps();
++- fones = _mm256_set1_ps(1.0);
++- ftwos = _mm256_set1_ps(2.0);
++- ffours = _mm256_set1_ps(4.0);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- aVal = _mm256_div_ps(aVal, _mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal), _mm256_sub_ps(fones, aVal))));
++- z = aVal;
++- condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
++- z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
++- condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
++- x = _mm256_add_ps(z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++){
++- x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_fmadd_ps(x,x,fones)));
++- }
++- x = _mm256_div_ps(fones, x);
++- y = fzeroes;
++- for(j = ASIN_TERMS - 1; j >=0 ; j--){
++- y = _mm256_fmadd_ps(y, _mm256_mul_ps(x, x), _mm256_set1_ps(pow(-1,j)/(2*j+1)));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ int i, j;
+++
+++ __m256 aVal, pio2, x, y, z, arcsine;
+++ __m256 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pio2 = _mm256_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm256_setzero_ps();
+++ fones = _mm256_set1_ps(1.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ ffours = _mm256_set1_ps(4.0);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ aVal = _mm256_div_ps(aVal,
+++ _mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal),
+++ _mm256_sub_ps(fones, aVal))));
+++ z = aVal;
+++ condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
+++ z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
+++ x = _mm256_add_ps(
+++ z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++) {
+++ x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_fmadd_ps(x, x, fones)));
+++ }
+++ x = _mm256_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = ASIN_TERMS - 1; j >= 0; j--) {
+++ y = _mm256_fmadd_ps(
+++ y, _mm256_mul_ps(x, x), _mm256_set1_ps(pow(-1, j) / (2 * j + 1)));
+++ }
+++
+++ y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
+++
+++ y = _mm256_add_ps(y, _mm256_and_ps(_mm256_fnmadd_ps(y, ftwos, pio2), condition));
+++ arcsine = y;
+++ condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
+++ arcsine = _mm256_sub_ps(arcsine,
+++ _mm256_and_ps(_mm256_mul_ps(arcsine, ftwos), condition));
+++
+++ _mm256_storeu_ps(bPtr, arcsine);
+++ aPtr += 8;
+++ bPtr += 8;
++ }
++
++- y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
++- condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
++-
++- y = _mm256_add_ps(y, _mm256_and_ps(_mm256_fnmadd_ps(y,ftwos,pio2), condition));
++- arcsine = y;
++- condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
++- arcsine = _mm256_sub_ps(arcsine, _mm256_and_ps(_mm256_mul_ps(arcsine, ftwos), condition));
++-
++- _mm256_storeu_ps(bPtr, arcsine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = asin(*aPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = asin(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for unaligned */
++@@ -334,57 +357,64 @@ volk_32f_asin_32f_u_avx2_fma(float* bVector, const float* aVector, unsigned int
++ static inline void
++ volk_32f_asin_32f_u_avx(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- int i, j;
++-
++- __m256 aVal, pio2, x, y, z, arcsine;
++- __m256 fzeroes, fones, ftwos, ffours, condition;
++-
++- pio2 = _mm256_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm256_setzero_ps();
++- fones = _mm256_set1_ps(1.0);
++- ftwos = _mm256_set1_ps(2.0);
++- ffours = _mm256_set1_ps(4.0);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- aVal = _mm256_div_ps(aVal, _mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal), _mm256_sub_ps(fones, aVal))));
++- z = aVal;
++- condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
++- z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
++- condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
++- x = _mm256_add_ps(z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++){
++- x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_add_ps(fones, _mm256_mul_ps(x, x))));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ int i, j;
+++
+++ __m256 aVal, pio2, x, y, z, arcsine;
+++ __m256 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pio2 = _mm256_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm256_setzero_ps();
+++ fones = _mm256_set1_ps(1.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ ffours = _mm256_set1_ps(4.0);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ aVal = _mm256_div_ps(aVal,
+++ _mm256_sqrt_ps(_mm256_mul_ps(_mm256_add_ps(fones, aVal),
+++ _mm256_sub_ps(fones, aVal))));
+++ z = aVal;
+++ condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
+++ z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
+++ x = _mm256_add_ps(
+++ z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++) {
+++ x = _mm256_add_ps(x,
+++ _mm256_sqrt_ps(_mm256_add_ps(fones, _mm256_mul_ps(x, x))));
+++ }
+++ x = _mm256_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = ASIN_TERMS - 1; j >= 0; j--) {
+++ y = _mm256_add_ps(_mm256_mul_ps(y, _mm256_mul_ps(x, x)),
+++ _mm256_set1_ps(pow(-1, j) / (2 * j + 1)));
+++ }
+++
+++ y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
+++
+++ y = _mm256_add_ps(
+++ y, _mm256_and_ps(_mm256_sub_ps(pio2, _mm256_mul_ps(y, ftwos)), condition));
+++ arcsine = y;
+++ condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
+++ arcsine = _mm256_sub_ps(arcsine,
+++ _mm256_and_ps(_mm256_mul_ps(arcsine, ftwos), condition));
+++
+++ _mm256_storeu_ps(bPtr, arcsine);
+++ aPtr += 8;
+++ bPtr += 8;
++ }
++- x = _mm256_div_ps(fones, x);
++- y = fzeroes;
++- for(j = ASIN_TERMS - 1; j >=0 ; j--){
++- y = _mm256_add_ps(_mm256_mul_ps(y, _mm256_mul_ps(x, x)), _mm256_set1_ps(pow(-1,j)/(2*j+1)));
++- }
++-
++- y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
++- condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
++
++- y = _mm256_add_ps(y, _mm256_and_ps(_mm256_sub_ps(pio2, _mm256_mul_ps(y, ftwos)), condition));
++- arcsine = y;
++- condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
++- arcsine = _mm256_sub_ps(arcsine, _mm256_and_ps(_mm256_mul_ps(arcsine, ftwos), condition));
++-
++- _mm256_storeu_ps(bPtr, arcsine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = asin(*aPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = asin(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX for unaligned */
++@@ -396,57 +426,60 @@ volk_32f_asin_32f_u_avx(float* bVector, const float* aVector, unsigned int num_p
++ static inline void
++ volk_32f_asin_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int quarterPoints = num_points / 4;
++- int i, j;
++-
++- __m128 aVal, pio2, x, y, z, arcsine;
++- __m128 fzeroes, fones, ftwos, ffours, condition;
++-
++- pio2 = _mm_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm_setzero_ps();
++- fones = _mm_set1_ps(1.0);
++- ftwos = _mm_set1_ps(2.0);
++- ffours = _mm_set1_ps(4.0);
++-
++- for(;number < quarterPoints; number++){
++- aVal = _mm_loadu_ps(aPtr);
++- aVal = _mm_div_ps(aVal, _mm_sqrt_ps(_mm_mul_ps(_mm_add_ps(fones, aVal), _mm_sub_ps(fones, aVal))));
++- z = aVal;
++- condition = _mm_cmplt_ps(z, fzeroes);
++- z = _mm_sub_ps(z, _mm_and_ps(_mm_mul_ps(z, ftwos), condition));
++- condition = _mm_cmplt_ps(z, fones);
++- x = _mm_add_ps(z, _mm_and_ps(_mm_sub_ps(_mm_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++){
++- x = _mm_add_ps(x, _mm_sqrt_ps(_mm_add_ps(fones, _mm_mul_ps(x, x))));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int quarterPoints = num_points / 4;
+++ int i, j;
+++
+++ __m128 aVal, pio2, x, y, z, arcsine;
+++ __m128 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pio2 = _mm_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm_setzero_ps();
+++ fones = _mm_set1_ps(1.0);
+++ ftwos = _mm_set1_ps(2.0);
+++ ffours = _mm_set1_ps(4.0);
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_loadu_ps(aPtr);
+++ aVal = _mm_div_ps(
+++ aVal,
+++ _mm_sqrt_ps(_mm_mul_ps(_mm_add_ps(fones, aVal), _mm_sub_ps(fones, aVal))));
+++ z = aVal;
+++ condition = _mm_cmplt_ps(z, fzeroes);
+++ z = _mm_sub_ps(z, _mm_and_ps(_mm_mul_ps(z, ftwos), condition));
+++ condition = _mm_cmplt_ps(z, fones);
+++ x = _mm_add_ps(z, _mm_and_ps(_mm_sub_ps(_mm_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++) {
+++ x = _mm_add_ps(x, _mm_sqrt_ps(_mm_add_ps(fones, _mm_mul_ps(x, x))));
+++ }
+++ x = _mm_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = ASIN_TERMS - 1; j >= 0; j--) {
+++ y = _mm_add_ps(_mm_mul_ps(y, _mm_mul_ps(x, x)),
+++ _mm_set1_ps(pow(-1, j) / (2 * j + 1)));
+++ }
+++
+++ y = _mm_mul_ps(y, _mm_mul_ps(x, ffours));
+++ condition = _mm_cmpgt_ps(z, fones);
+++
+++ y = _mm_add_ps(y, _mm_and_ps(_mm_sub_ps(pio2, _mm_mul_ps(y, ftwos)), condition));
+++ arcsine = y;
+++ condition = _mm_cmplt_ps(aVal, fzeroes);
+++ arcsine = _mm_sub_ps(arcsine, _mm_and_ps(_mm_mul_ps(arcsine, ftwos), condition));
+++
+++ _mm_storeu_ps(bPtr, arcsine);
+++ aPtr += 4;
+++ bPtr += 4;
++ }
++- x = _mm_div_ps(fones, x);
++- y = fzeroes;
++- for(j = ASIN_TERMS - 1; j >=0 ; j--){
++- y = _mm_add_ps(_mm_mul_ps(y, _mm_mul_ps(x, x)), _mm_set1_ps(pow(-1,j)/(2*j+1)));
++- }
++-
++- y = _mm_mul_ps(y, _mm_mul_ps(x, ffours));
++- condition = _mm_cmpgt_ps(z, fones);
++
++- y = _mm_add_ps(y, _mm_and_ps(_mm_sub_ps(pio2, _mm_mul_ps(y, ftwos)), condition));
++- arcsine = y;
++- condition = _mm_cmplt_ps(aVal, fzeroes);
++- arcsine = _mm_sub_ps(arcsine, _mm_and_ps(_mm_mul_ps(arcsine, ftwos), condition));
++-
++- _mm_storeu_ps(bPtr, arcsine);
++- aPtr += 4;
++- bPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *bPtr++ = asinf(*aPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = asinf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for unaligned */
++@@ -456,13 +489,13 @@ volk_32f_asin_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int nu
++ static inline void
++ volk_32f_asin_32f_u_generic(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *bPtr++ = asinf(*aPtr++);
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *bPtr++ = asinf(*aPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32f_atan_32f.h b/kernels/volk/volk_32f_atan_32f.h
++index 3496f0e..6652ee8 100644
++--- a/kernels/volk/volk_32f_atan_32f.h
+++++ b/kernels/volk/volk_32f_atan_32f.h
++@@ -67,11 +67,12 @@
++ * \endcode
++ */
++
++-#include <stdio.h>
++-#include <math.h>
++ #include <inttypes.h>
+++#include <math.h>
+++#include <stdio.h>
++
++-/* This is the number of terms of Taylor series to evaluate, increase this for more accuracy*/
+++/* This is the number of terms of Taylor series to evaluate, increase this for more
+++ * accuracy*/
++ #define TERMS 2
++
++ #ifndef INCLUDED_volk_32f_atan_32f_a_H
++@@ -80,59 +81,63 @@
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_atan_32f_a_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_atan_32f_a_avx2_fma(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- int i, j;
++-
++- __m256 aVal, pio2, x, y, z, arctangent;
++- __m256 fzeroes, fones, ftwos, ffours, condition;
++-
++- pio2 = _mm256_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm256_setzero_ps();
++- fones = _mm256_set1_ps(1.0);
++- ftwos = _mm256_set1_ps(2.0);
++- ffours = _mm256_set1_ps(4.0);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- z = aVal;
++- condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
++- z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
++- condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
++- x = _mm256_add_ps(z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++){
++- x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_fmadd_ps(x,x,fones)));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ int i, j;
+++
+++ __m256 aVal, pio2, x, y, z, arctangent;
+++ __m256 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pio2 = _mm256_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm256_setzero_ps();
+++ fones = _mm256_set1_ps(1.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ ffours = _mm256_set1_ps(4.0);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ z = aVal;
+++ condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
+++ z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
+++ x = _mm256_add_ps(
+++ z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++) {
+++ x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_fmadd_ps(x, x, fones)));
+++ }
+++ x = _mm256_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = TERMS - 1; j >= 0; j--) {
+++ y = _mm256_fmadd_ps(
+++ y, _mm256_mul_ps(x, x), _mm256_set1_ps(pow(-1, j) / (2 * j + 1)));
+++ }
+++
+++ y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
+++
+++ y = _mm256_add_ps(y, _mm256_and_ps(_mm256_fnmadd_ps(y, ftwos, pio2), condition));
+++ arctangent = y;
+++ condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
+++ arctangent = _mm256_sub_ps(
+++ arctangent, _mm256_and_ps(_mm256_mul_ps(arctangent, ftwos), condition));
+++
+++ _mm256_store_ps(bPtr, arctangent);
+++ aPtr += 8;
+++ bPtr += 8;
++ }
++- x = _mm256_div_ps(fones, x);
++- y = fzeroes;
++- for(j = TERMS - 1; j >=0 ; j--){
++- y = _mm256_fmadd_ps(y, _mm256_mul_ps(x, x), _mm256_set1_ps(pow(-1,j)/(2*j+1)));
++- }
++-
++- y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
++- condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
++-
++- y = _mm256_add_ps(y, _mm256_and_ps(_mm256_fnmadd_ps(y,ftwos,pio2), condition));
++- arctangent = y;
++- condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
++- arctangent = _mm256_sub_ps(arctangent, _mm256_and_ps(_mm256_mul_ps(arctangent, ftwos), condition));
++-
++- _mm256_store_ps(bPtr, arctangent);
++- aPtr += 8;
++- bPtr += 8;
++- }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = atan(*aPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = atan(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for aligned */
++@@ -144,56 +149,61 @@ volk_32f_atan_32f_a_avx2_fma(float* bVector, const float* aVector, unsigned int
++ static inline void
++ volk_32f_atan_32f_a_avx(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- int i, j;
++-
++- __m256 aVal, pio2, x, y, z, arctangent;
++- __m256 fzeroes, fones, ftwos, ffours, condition;
++-
++- pio2 = _mm256_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm256_setzero_ps();
++- fones = _mm256_set1_ps(1.0);
++- ftwos = _mm256_set1_ps(2.0);
++- ffours = _mm256_set1_ps(4.0);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- z = aVal;
++- condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
++- z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
++- condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
++- x = _mm256_add_ps(z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++){
++- x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_add_ps(fones, _mm256_mul_ps(x, x))));
++- }
++- x = _mm256_div_ps(fones, x);
++- y = fzeroes;
++- for(j = TERMS - 1; j >=0 ; j--){
++- y = _mm256_add_ps(_mm256_mul_ps(y, _mm256_mul_ps(x, x)), _mm256_set1_ps(pow(-1,j)/(2*j+1)));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ int i, j;
+++
+++ __m256 aVal, pio2, x, y, z, arctangent;
+++ __m256 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pio2 = _mm256_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm256_setzero_ps();
+++ fones = _mm256_set1_ps(1.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ ffours = _mm256_set1_ps(4.0);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ z = aVal;
+++ condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
+++ z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
+++ x = _mm256_add_ps(
+++ z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++) {
+++ x = _mm256_add_ps(x,
+++ _mm256_sqrt_ps(_mm256_add_ps(fones, _mm256_mul_ps(x, x))));
+++ }
+++ x = _mm256_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = TERMS - 1; j >= 0; j--) {
+++ y = _mm256_add_ps(_mm256_mul_ps(y, _mm256_mul_ps(x, x)),
+++ _mm256_set1_ps(pow(-1, j) / (2 * j + 1)));
+++ }
+++
+++ y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
+++
+++ y = _mm256_add_ps(
+++ y, _mm256_and_ps(_mm256_sub_ps(pio2, _mm256_mul_ps(y, ftwos)), condition));
+++ arctangent = y;
+++ condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
+++ arctangent = _mm256_sub_ps(
+++ arctangent, _mm256_and_ps(_mm256_mul_ps(arctangent, ftwos), condition));
+++
+++ _mm256_store_ps(bPtr, arctangent);
+++ aPtr += 8;
+++ bPtr += 8;
++ }
++
++- y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
++- condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
++-
++- y = _mm256_add_ps(y, _mm256_and_ps(_mm256_sub_ps(pio2, _mm256_mul_ps(y, ftwos)), condition));
++- arctangent = y;
++- condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
++- arctangent = _mm256_sub_ps(arctangent, _mm256_and_ps(_mm256_mul_ps(arctangent, ftwos), condition));
++-
++- _mm256_store_ps(bPtr, arctangent);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = atan(*aPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = atan(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX for aligned */
++@@ -204,56 +214,58 @@ volk_32f_atan_32f_a_avx(float* bVector, const float* aVector, unsigned int num_p
++ static inline void
++ volk_32f_atan_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int quarterPoints = num_points / 4;
++- int i, j;
++-
++- __m128 aVal, pio2, x, y, z, arctangent;
++- __m128 fzeroes, fones, ftwos, ffours, condition;
++-
++- pio2 = _mm_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm_setzero_ps();
++- fones = _mm_set1_ps(1.0);
++- ftwos = _mm_set1_ps(2.0);
++- ffours = _mm_set1_ps(4.0);
++-
++- for(;number < quarterPoints; number++){
++- aVal = _mm_load_ps(aPtr);
++- z = aVal;
++- condition = _mm_cmplt_ps(z, fzeroes);
++- z = _mm_sub_ps(z, _mm_and_ps(_mm_mul_ps(z, ftwos), condition));
++- condition = _mm_cmplt_ps(z, fones);
++- x = _mm_add_ps(z, _mm_and_ps(_mm_sub_ps(_mm_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++){
++- x = _mm_add_ps(x, _mm_sqrt_ps(_mm_add_ps(fones, _mm_mul_ps(x, x))));
++- }
++- x = _mm_div_ps(fones, x);
++- y = fzeroes;
++- for(j = TERMS - 1; j >=0 ; j--){
++- y = _mm_add_ps(_mm_mul_ps(y, _mm_mul_ps(x, x)), _mm_set1_ps(pow(-1,j)/(2*j+1)));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int quarterPoints = num_points / 4;
+++ int i, j;
+++
+++ __m128 aVal, pio2, x, y, z, arctangent;
+++ __m128 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pio2 = _mm_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm_setzero_ps();
+++ fones = _mm_set1_ps(1.0);
+++ ftwos = _mm_set1_ps(2.0);
+++ ffours = _mm_set1_ps(4.0);
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
+++ z = aVal;
+++ condition = _mm_cmplt_ps(z, fzeroes);
+++ z = _mm_sub_ps(z, _mm_and_ps(_mm_mul_ps(z, ftwos), condition));
+++ condition = _mm_cmplt_ps(z, fones);
+++ x = _mm_add_ps(z, _mm_and_ps(_mm_sub_ps(_mm_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++) {
+++ x = _mm_add_ps(x, _mm_sqrt_ps(_mm_add_ps(fones, _mm_mul_ps(x, x))));
+++ }
+++ x = _mm_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = TERMS - 1; j >= 0; j--) {
+++ y = _mm_add_ps(_mm_mul_ps(y, _mm_mul_ps(x, x)),
+++ _mm_set1_ps(pow(-1, j) / (2 * j + 1)));
+++ }
+++
+++ y = _mm_mul_ps(y, _mm_mul_ps(x, ffours));
+++ condition = _mm_cmpgt_ps(z, fones);
+++
+++ y = _mm_add_ps(y, _mm_and_ps(_mm_sub_ps(pio2, _mm_mul_ps(y, ftwos)), condition));
+++ arctangent = y;
+++ condition = _mm_cmplt_ps(aVal, fzeroes);
+++ arctangent =
+++ _mm_sub_ps(arctangent, _mm_and_ps(_mm_mul_ps(arctangent, ftwos), condition));
+++
+++ _mm_store_ps(bPtr, arctangent);
+++ aPtr += 4;
+++ bPtr += 4;
++ }
++
++- y = _mm_mul_ps(y, _mm_mul_ps(x, ffours));
++- condition = _mm_cmpgt_ps(z, fones);
++-
++- y = _mm_add_ps(y, _mm_and_ps(_mm_sub_ps(pio2, _mm_mul_ps(y, ftwos)), condition));
++- arctangent = y;
++- condition = _mm_cmplt_ps(aVal, fzeroes);
++- arctangent = _mm_sub_ps(arctangent, _mm_and_ps(_mm_mul_ps(arctangent, ftwos), condition));
++-
++- _mm_store_ps(bPtr, arctangent);
++- aPtr += 4;
++- bPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *bPtr++ = atanf(*aPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = atanf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for aligned */
++@@ -266,59 +278,63 @@ volk_32f_atan_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int nu
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_atan_32f_u_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_atan_32f_u_avx2_fma(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- int i, j;
++-
++- __m256 aVal, pio2, x, y, z, arctangent;
++- __m256 fzeroes, fones, ftwos, ffours, condition;
++-
++- pio2 = _mm256_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm256_setzero_ps();
++- fones = _mm256_set1_ps(1.0);
++- ftwos = _mm256_set1_ps(2.0);
++- ffours = _mm256_set1_ps(4.0);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- z = aVal;
++- condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
++- z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
++- condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
++- x = _mm256_add_ps(z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++){
++- x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_fmadd_ps(x,x,fones)));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ int i, j;
+++
+++ __m256 aVal, pio2, x, y, z, arctangent;
+++ __m256 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pio2 = _mm256_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm256_setzero_ps();
+++ fones = _mm256_set1_ps(1.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ ffours = _mm256_set1_ps(4.0);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ z = aVal;
+++ condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
+++ z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
+++ x = _mm256_add_ps(
+++ z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++) {
+++ x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_fmadd_ps(x, x, fones)));
+++ }
+++ x = _mm256_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = TERMS - 1; j >= 0; j--) {
+++ y = _mm256_fmadd_ps(
+++ y, _mm256_mul_ps(x, x), _mm256_set1_ps(pow(-1, j) / (2 * j + 1)));
+++ }
+++
+++ y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
+++
+++ y = _mm256_add_ps(y, _mm256_and_ps(_mm256_fnmadd_ps(y, ftwos, pio2), condition));
+++ arctangent = y;
+++ condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
+++ arctangent = _mm256_sub_ps(
+++ arctangent, _mm256_and_ps(_mm256_mul_ps(arctangent, ftwos), condition));
+++
+++ _mm256_storeu_ps(bPtr, arctangent);
+++ aPtr += 8;
+++ bPtr += 8;
++ }
++- x = _mm256_div_ps(fones, x);
++- y = fzeroes;
++- for(j = TERMS - 1; j >=0 ; j--){
++- y = _mm256_fmadd_ps(y, _mm256_mul_ps(x, x), _mm256_set1_ps(pow(-1,j)/(2*j+1)));
++- }
++-
++- y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
++- condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
++
++- y = _mm256_add_ps(y, _mm256_and_ps(_mm256_fnmadd_ps(y,ftwos,pio2), condition));
++- arctangent = y;
++- condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
++- arctangent = _mm256_sub_ps(arctangent, _mm256_and_ps(_mm256_mul_ps(arctangent, ftwos), condition));
++-
++- _mm256_storeu_ps(bPtr, arctangent);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = atan(*aPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = atan(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for unaligned */
++@@ -330,56 +346,61 @@ volk_32f_atan_32f_u_avx2_fma(float* bVector, const float* aVector, unsigned int
++ static inline void
++ volk_32f_atan_32f_u_avx(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- int i, j;
++-
++- __m256 aVal, pio2, x, y, z, arctangent;
++- __m256 fzeroes, fones, ftwos, ffours, condition;
++-
++- pio2 = _mm256_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm256_setzero_ps();
++- fones = _mm256_set1_ps(1.0);
++- ftwos = _mm256_set1_ps(2.0);
++- ffours = _mm256_set1_ps(4.0);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- z = aVal;
++- condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
++- z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
++- condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
++- x = _mm256_add_ps(z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++){
++- x = _mm256_add_ps(x, _mm256_sqrt_ps(_mm256_add_ps(fones, _mm256_mul_ps(x, x))));
++- }
++- x = _mm256_div_ps(fones, x);
++- y = fzeroes;
++- for(j = TERMS - 1; j >=0 ; j--){
++- y = _mm256_add_ps(_mm256_mul_ps(y, _mm256_mul_ps(x, x)), _mm256_set1_ps(pow(-1,j)/(2*j+1)));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ int i, j;
+++
+++ __m256 aVal, pio2, x, y, z, arctangent;
+++ __m256 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pio2 = _mm256_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm256_setzero_ps();
+++ fones = _mm256_set1_ps(1.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ ffours = _mm256_set1_ps(4.0);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ z = aVal;
+++ condition = _mm256_cmp_ps(z, fzeroes, _CMP_LT_OS);
+++ z = _mm256_sub_ps(z, _mm256_and_ps(_mm256_mul_ps(z, ftwos), condition));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_LT_OS);
+++ x = _mm256_add_ps(
+++ z, _mm256_and_ps(_mm256_sub_ps(_mm256_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++) {
+++ x = _mm256_add_ps(x,
+++ _mm256_sqrt_ps(_mm256_add_ps(fones, _mm256_mul_ps(x, x))));
+++ }
+++ x = _mm256_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = TERMS - 1; j >= 0; j--) {
+++ y = _mm256_add_ps(_mm256_mul_ps(y, _mm256_mul_ps(x, x)),
+++ _mm256_set1_ps(pow(-1, j) / (2 * j + 1)));
+++ }
+++
+++ y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
+++ condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
+++
+++ y = _mm256_add_ps(
+++ y, _mm256_and_ps(_mm256_sub_ps(pio2, _mm256_mul_ps(y, ftwos)), condition));
+++ arctangent = y;
+++ condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
+++ arctangent = _mm256_sub_ps(
+++ arctangent, _mm256_and_ps(_mm256_mul_ps(arctangent, ftwos), condition));
+++
+++ _mm256_storeu_ps(bPtr, arctangent);
+++ aPtr += 8;
+++ bPtr += 8;
++ }
++
++- y = _mm256_mul_ps(y, _mm256_mul_ps(x, ffours));
++- condition = _mm256_cmp_ps(z, fones, _CMP_GT_OS);
++-
++- y = _mm256_add_ps(y, _mm256_and_ps(_mm256_sub_ps(pio2, _mm256_mul_ps(y, ftwos)), condition));
++- arctangent = y;
++- condition = _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS);
++- arctangent = _mm256_sub_ps(arctangent, _mm256_and_ps(_mm256_mul_ps(arctangent, ftwos), condition));
++-
++- _mm256_storeu_ps(bPtr, arctangent);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = atan(*aPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = atan(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX for unaligned */
++@@ -390,54 +411,56 @@ volk_32f_atan_32f_u_avx(float* bVector, const float* aVector, unsigned int num_p
++ static inline void
++ volk_32f_atan_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int quarterPoints = num_points / 4;
++- int i, j;
++-
++- __m128 aVal, pio2, x, y, z, arctangent;
++- __m128 fzeroes, fones, ftwos, ffours, condition;
++-
++- pio2 = _mm_set1_ps(3.14159265358979323846/2);
++- fzeroes = _mm_setzero_ps();
++- fones = _mm_set1_ps(1.0);
++- ftwos = _mm_set1_ps(2.0);
++- ffours = _mm_set1_ps(4.0);
++-
++- for(;number < quarterPoints; number++){
++- aVal = _mm_loadu_ps(aPtr);
++- z = aVal;
++- condition = _mm_cmplt_ps(z, fzeroes);
++- z = _mm_sub_ps(z, _mm_and_ps(_mm_mul_ps(z, ftwos), condition));
++- condition = _mm_cmplt_ps(z, fones);
++- x = _mm_add_ps(z, _mm_and_ps(_mm_sub_ps(_mm_div_ps(fones, z), z), condition));
++-
++- for(i = 0; i < 2; i++)
++- x = _mm_add_ps(x, _mm_sqrt_ps(_mm_add_ps(fones, _mm_mul_ps(x, x))));
++- x = _mm_div_ps(fones, x);
++- y = fzeroes;
++- for(j = TERMS - 1; j >= 0; j--)
++- y = _mm_add_ps(_mm_mul_ps(y, _mm_mul_ps(x, x)), _mm_set1_ps(pow(-1,j)/(2*j+1)));
++-
++- y = _mm_mul_ps(y, _mm_mul_ps(x, ffours));
++- condition = _mm_cmpgt_ps(z, fones);
++-
++- y = _mm_add_ps(y, _mm_and_ps(_mm_sub_ps(pio2, _mm_mul_ps(y, ftwos)), condition));
++- arctangent = y;
++- condition = _mm_cmplt_ps(aVal, fzeroes);
++- arctangent = _mm_sub_ps(arctangent, _mm_and_ps(_mm_mul_ps(arctangent, ftwos), condition));
++-
++- _mm_storeu_ps(bPtr, arctangent);
++- aPtr += 4;
++- bPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *bPtr++ = atanf(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int quarterPoints = num_points / 4;
+++ int i, j;
+++
+++ __m128 aVal, pio2, x, y, z, arctangent;
+++ __m128 fzeroes, fones, ftwos, ffours, condition;
+++
+++ pio2 = _mm_set1_ps(3.14159265358979323846 / 2);
+++ fzeroes = _mm_setzero_ps();
+++ fones = _mm_set1_ps(1.0);
+++ ftwos = _mm_set1_ps(2.0);
+++ ffours = _mm_set1_ps(4.0);
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_loadu_ps(aPtr);
+++ z = aVal;
+++ condition = _mm_cmplt_ps(z, fzeroes);
+++ z = _mm_sub_ps(z, _mm_and_ps(_mm_mul_ps(z, ftwos), condition));
+++ condition = _mm_cmplt_ps(z, fones);
+++ x = _mm_add_ps(z, _mm_and_ps(_mm_sub_ps(_mm_div_ps(fones, z), z), condition));
+++
+++ for (i = 0; i < 2; i++)
+++ x = _mm_add_ps(x, _mm_sqrt_ps(_mm_add_ps(fones, _mm_mul_ps(x, x))));
+++ x = _mm_div_ps(fones, x);
+++ y = fzeroes;
+++ for (j = TERMS - 1; j >= 0; j--)
+++ y = _mm_add_ps(_mm_mul_ps(y, _mm_mul_ps(x, x)),
+++ _mm_set1_ps(pow(-1, j) / (2 * j + 1)));
+++
+++ y = _mm_mul_ps(y, _mm_mul_ps(x, ffours));
+++ condition = _mm_cmpgt_ps(z, fones);
+++
+++ y = _mm_add_ps(y, _mm_and_ps(_mm_sub_ps(pio2, _mm_mul_ps(y, ftwos)), condition));
+++ arctangent = y;
+++ condition = _mm_cmplt_ps(aVal, fzeroes);
+++ arctangent =
+++ _mm_sub_ps(arctangent, _mm_and_ps(_mm_mul_ps(arctangent, ftwos), condition));
+++
+++ _mm_storeu_ps(bPtr, arctangent);
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = atanf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for unaligned */
++@@ -447,13 +470,13 @@ volk_32f_atan_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int nu
++ static inline void
++ volk_32f_atan_32f_generic(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *bPtr++ = atanf(*aPtr++);
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *bPtr++ = atanf(*aPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32f_binary_slicer_32i.h b/kernels/volk/volk_32f_binary_slicer_32i.h
++index c56ff8f..635d0c3 100644
++--- a/kernels/volk/volk_32f_binary_slicer_32i.h
+++++ b/kernels/volk/volk_32f_binary_slicer_32i.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_binary_slicer_32i(int* cVector, const float* aVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_binary_slicer_32i(int* cVector, const float* aVector, unsigned int
+++ * num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: The input vector of floats.
++@@ -73,37 +73,38 @@
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_binary_slicer_32i_generic(int* cVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_binary_slicer_32i_generic(int* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- int* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- if( *aPtr++ >= 0) {
++- *cPtr++ = 1;
++- }
++- else {
++- *cPtr++ = 0;
+++ int* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ if (*aPtr++ >= 0) {
+++ *cPtr++ = 1;
+++ } else {
+++ *cPtr++ = 0;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_binary_slicer_32i_generic_branchless(int* cVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_binary_slicer_32i_generic_branchless(int* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- int* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
+++ int* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++ >= 0);
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++ >= 0);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -111,40 +112,40 @@ volk_32f_binary_slicer_32i_generic_branchless(int* cVector, const float* aVector
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32f_binary_slicer_32i_a_sse2(int* cVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_binary_slicer_32i_a_sse2(int* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- int* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++-
++- unsigned int quarter_points = num_points / 4;
++- __m128 a_val, res_f;
++- __m128i res_i, binary_i;
++- __m128 zero_val;
++- zero_val = _mm_set1_ps (0.0f);
+++ int* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < quarter_points; number++){
++- a_val = _mm_load_ps(aPtr);
+++ unsigned int quarter_points = num_points / 4;
+++ __m128 a_val, res_f;
+++ __m128i res_i, binary_i;
+++ __m128 zero_val;
+++ zero_val = _mm_set1_ps(0.0f);
++
++- res_f = _mm_cmpge_ps (a_val, zero_val);
++- res_i = _mm_cvtps_epi32 (res_f);
++- binary_i = _mm_srli_epi32 (res_i, 31);
+++ for (number = 0; number < quarter_points; number++) {
+++ a_val = _mm_load_ps(aPtr);
++
++- _mm_store_si128((__m128i*)cPtr, binary_i);
+++ res_f = _mm_cmpge_ps(a_val, zero_val);
+++ res_i = _mm_cvtps_epi32(res_f);
+++ binary_i = _mm_srli_epi32(res_i, 31);
++
++- cPtr += 4;
++- aPtr += 4;
++- }
+++ _mm_store_si128((__m128i*)cPtr, binary_i);
++
++- for(number = quarter_points * 4; number < num_points; number++){
++- if( *aPtr++ >= 0) {
++- *cPtr++ = 1;
+++ cPtr += 4;
+++ aPtr += 4;
++ }
++- else {
++- *cPtr++ = 0;
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ if (*aPtr++ >= 0) {
+++ *cPtr++ = 1;
+++ } else {
+++ *cPtr++ = 0;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++@@ -152,41 +153,41 @@ volk_32f_binary_slicer_32i_a_sse2(int* cVector, const float* aVector, unsigned i
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_binary_slicer_32i_a_avx(int* cVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_binary_slicer_32i_a_avx(int* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- int* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
+++ int* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- unsigned int quarter_points = num_points / 8;
++- __m256 a_val, res_f, binary_f;
++- __m256i binary_i;
++- __m256 zero_val, one_val;
++- zero_val = _mm256_set1_ps (0.0f);
++- one_val = _mm256_set1_ps (1.0f);
+++ unsigned int quarter_points = num_points / 8;
+++ __m256 a_val, res_f, binary_f;
+++ __m256i binary_i;
+++ __m256 zero_val, one_val;
+++ zero_val = _mm256_set1_ps(0.0f);
+++ one_val = _mm256_set1_ps(1.0f);
++
++- for(number = 0; number < quarter_points; number++){
++- a_val = _mm256_load_ps(aPtr);
+++ for (number = 0; number < quarter_points; number++) {
+++ a_val = _mm256_load_ps(aPtr);
++
++- res_f = _mm256_cmp_ps (a_val, zero_val, _CMP_GE_OS);
++- binary_f = _mm256_and_ps (res_f, one_val);
++- binary_i = _mm256_cvtps_epi32(binary_f);
+++ res_f = _mm256_cmp_ps(a_val, zero_val, _CMP_GE_OS);
+++ binary_f = _mm256_and_ps(res_f, one_val);
+++ binary_i = _mm256_cvtps_epi32(binary_f);
++
++- _mm256_store_si256((__m256i *)cPtr, binary_i);
+++ _mm256_store_si256((__m256i*)cPtr, binary_i);
++
++- cPtr += 8;
++- aPtr += 8;
++- }
++-
++- for(number = quarter_points * 8; number < num_points; number++){
++- if( *aPtr++ >= 0) {
++- *cPtr++ = 1;
+++ cPtr += 8;
+++ aPtr += 8;
++ }
++- else {
++- *cPtr++ = 0;
+++
+++ for (number = quarter_points * 8; number < num_points; number++) {
+++ if (*aPtr++ >= 0) {
+++ *cPtr++ = 1;
+++ } else {
+++ *cPtr++ = 0;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -194,40 +195,40 @@ volk_32f_binary_slicer_32i_a_avx(int* cVector, const float* aVector, unsigned in
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32f_binary_slicer_32i_u_sse2(int* cVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_binary_slicer_32i_u_sse2(int* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- int* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++-
++- unsigned int quarter_points = num_points / 4;
++- __m128 a_val, res_f;
++- __m128i res_i, binary_i;
++- __m128 zero_val;
++- zero_val = _mm_set1_ps (0.0f);
+++ int* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < quarter_points; number++){
++- a_val = _mm_loadu_ps(aPtr);
+++ unsigned int quarter_points = num_points / 4;
+++ __m128 a_val, res_f;
+++ __m128i res_i, binary_i;
+++ __m128 zero_val;
+++ zero_val = _mm_set1_ps(0.0f);
++
++- res_f = _mm_cmpge_ps (a_val, zero_val);
++- res_i = _mm_cvtps_epi32 (res_f);
++- binary_i = _mm_srli_epi32 (res_i, 31);
+++ for (number = 0; number < quarter_points; number++) {
+++ a_val = _mm_loadu_ps(aPtr);
++
++- _mm_storeu_si128((__m128i*)cPtr, binary_i);
+++ res_f = _mm_cmpge_ps(a_val, zero_val);
+++ res_i = _mm_cvtps_epi32(res_f);
+++ binary_i = _mm_srli_epi32(res_i, 31);
++
++- cPtr += 4;
++- aPtr += 4;
++- }
+++ _mm_storeu_si128((__m128i*)cPtr, binary_i);
++
++- for(number = quarter_points * 4; number < num_points; number++){
++- if( *aPtr++ >= 0) {
++- *cPtr++ = 1;
+++ cPtr += 4;
+++ aPtr += 4;
++ }
++- else {
++- *cPtr++ = 0;
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ if (*aPtr++ >= 0) {
+++ *cPtr++ = 1;
+++ } else {
+++ *cPtr++ = 0;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++@@ -235,41 +236,41 @@ volk_32f_binary_slicer_32i_u_sse2(int* cVector, const float* aVector, unsigned i
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_binary_slicer_32i_u_avx(int* cVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_binary_slicer_32i_u_avx(int* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- int* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++-
++- unsigned int quarter_points = num_points / 8;
++- __m256 a_val, res_f, binary_f;
++- __m256i binary_i;
++- __m256 zero_val, one_val;
++- zero_val = _mm256_set1_ps (0.0f);
++- one_val = _mm256_set1_ps (1.0f);
+++ int* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < quarter_points; number++){
++- a_val = _mm256_loadu_ps(aPtr);
+++ unsigned int quarter_points = num_points / 8;
+++ __m256 a_val, res_f, binary_f;
+++ __m256i binary_i;
+++ __m256 zero_val, one_val;
+++ zero_val = _mm256_set1_ps(0.0f);
+++ one_val = _mm256_set1_ps(1.0f);
++
++- res_f = _mm256_cmp_ps (a_val, zero_val, _CMP_GE_OS);
++- binary_f = _mm256_and_ps (res_f, one_val);
++- binary_i = _mm256_cvtps_epi32(binary_f);
+++ for (number = 0; number < quarter_points; number++) {
+++ a_val = _mm256_loadu_ps(aPtr);
++
++- _mm256_storeu_si256((__m256i*)cPtr, binary_i);
+++ res_f = _mm256_cmp_ps(a_val, zero_val, _CMP_GE_OS);
+++ binary_f = _mm256_and_ps(res_f, one_val);
+++ binary_i = _mm256_cvtps_epi32(binary_f);
++
++- cPtr += 8;
++- aPtr += 8;
++- }
+++ _mm256_storeu_si256((__m256i*)cPtr, binary_i);
++
++- for(number = quarter_points * 8; number < num_points; number++){
++- if( *aPtr++ >= 0) {
++- *cPtr++ = 1;
+++ cPtr += 8;
+++ aPtr += 8;
++ }
++- else {
++- *cPtr++ = 0;
+++
+++ for (number = quarter_points * 8; number < num_points; number++) {
+++ if (*aPtr++ >= 0) {
+++ *cPtr++ = 1;
+++ } else {
+++ *cPtr++ = 0;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_AVX */
++
++diff --git a/kernels/volk/volk_32f_binary_slicer_8i.h b/kernels/volk/volk_32f_binary_slicer_8i.h
++index 5920621..3eddb5c 100644
++--- a/kernels/volk/volk_32f_binary_slicer_8i.h
+++++ b/kernels/volk/volk_32f_binary_slicer_8i.h
++@@ -30,7 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_binary_slicer_8i(int8_t* cVector, const float* aVector, unsigned int num_points)
+++ * void volk_32f_binary_slicer_8i(int8_t* cVector, const float* aVector, unsigned int
+++ num_points)
++ * \endcode
++ *
++ * \b Inputs
++@@ -74,39 +75,38 @@
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_binary_slicer_8i_generic(int8_t* cVector, const float* aVector,
++- unsigned int num_points)
+++static inline void volk_32f_binary_slicer_8i_generic(int8_t* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- int8_t* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++) {
++- if(*aPtr++ >= 0) {
++- *cPtr++ = 1;
++- }
++- else {
++- *cPtr++ = 0;
+++ int8_t* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ if (*aPtr++ >= 0) {
+++ *cPtr++ = 1;
+++ } else {
+++ *cPtr++ = 0;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_binary_slicer_8i_generic_branchless(int8_t* cVector, const float* aVector,
++- unsigned int num_points)
+++static inline void volk_32f_binary_slicer_8i_generic_branchless(int8_t* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- int8_t* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
+++ int8_t* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++ >= 0);
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++ >= 0);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -114,279 +114,329 @@ volk_32f_binary_slicer_8i_generic_branchless(int8_t* cVector, const float* aVect
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_binary_slicer_8i_a_avx2(int8_t* cVector, const float* aVector,
++- unsigned int num_points)
+++static inline void volk_32f_binary_slicer_8i_a_avx2(int8_t* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- int8_t* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++- unsigned int n32points = num_points / 32;
++-
++- const __m256 zero_val = _mm256_set1_ps(0.0f);
++- __m256 a0_val, a1_val, a2_val, a3_val;
++- __m256 res0_f, res1_f, res2_f, res3_f;
++- __m256i res0_i, res1_i, res2_i, res3_i;
++- __m256i byte_shuffle = _mm256_set_epi8( 15, 14, 13, 12, 7, 6, 5, 4,
++- 11, 10, 9, 8, 3, 2, 1, 0,
++- 15, 14, 13, 12, 7, 6, 5, 4,
++- 11, 10, 9, 8, 3, 2, 1, 0);
++-
++- for(number = 0; number < n32points; number++) {
++- a0_val = _mm256_load_ps(aPtr);
++- a1_val = _mm256_load_ps(aPtr+8);
++- a2_val = _mm256_load_ps(aPtr+16);
++- a3_val = _mm256_load_ps(aPtr+24);
++-
++- // compare >= 0; return float
++- res0_f = _mm256_cmp_ps(a0_val, zero_val, _CMP_GE_OS);
++- res1_f = _mm256_cmp_ps(a1_val, zero_val, _CMP_GE_OS);
++- res2_f = _mm256_cmp_ps(a2_val, zero_val, _CMP_GE_OS);
++- res3_f = _mm256_cmp_ps(a3_val, zero_val, _CMP_GE_OS);
++-
++- // convert to 32i and >> 31
++- res0_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res0_f), 31);
++- res1_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res1_f), 31);
++- res2_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res2_f), 31);
++- res3_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res3_f), 31);
++-
++- // pack in to 16-bit results
++- res0_i = _mm256_packs_epi32(res0_i, res1_i);
++- res2_i = _mm256_packs_epi32(res2_i, res3_i);
++- // pack in to 8-bit results
++- // res0: (after packs_epi32)
++- // a0, a1, a2, a3, b0, b1, b2, b3, a4, a5, a6, a7, b4, b5, b6, b7
++- // res2:
++- // c0, c1, c2, c3, d0, d1, d2, d3, c4, c5, c6, c7, d4, d5, d6, d7
++- res0_i = _mm256_packs_epi16(res0_i, res2_i);
++- // shuffle the lanes
++- // res0: (after packs_epi16)
++- // a0, a1, a2, a3, b0, b1, b2, b3, c0, c1, c2, c3, d0, d1, d2, d3
++- // a4, a5, a6, a7, b4, b5, b6, b7, c4, c5, c6, c7, d4, d5, d6, d7
++- // 0, 2, 1, 3 -> 11 01 10 00 (0xd8)
++- res0_i = _mm256_permute4x64_epi64(res0_i, 0xd8);
++-
++- // shuffle bytes within lanes
++- // res0: (after shuffle_epi8)
++- // a0, a1, a2, a3, b0, b1, b2, b3, a4, a5, a6, a7, b4, b5, b6, b7
++- // c0, c1, c2, c3, d0, d1, d2, d3, c4, c5, c6, c7, d4, d5, d6, d7
++- res0_i = _mm256_shuffle_epi8(res0_i, byte_shuffle);
++-
++- _mm256_store_si256((__m256i*)cPtr, res0_i);
++- aPtr += 32;
++- cPtr += 32;
++- }
++-
++- for(number = n32points * 32; number < num_points; number++) {
++- if( *aPtr++ >= 0) {
++- *cPtr++ = 1;
+++ int8_t* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
+++ unsigned int n32points = num_points / 32;
+++
+++ const __m256 zero_val = _mm256_set1_ps(0.0f);
+++ __m256 a0_val, a1_val, a2_val, a3_val;
+++ __m256 res0_f, res1_f, res2_f, res3_f;
+++ __m256i res0_i, res1_i, res2_i, res3_i;
+++ __m256i byte_shuffle = _mm256_set_epi8(15,
+++ 14,
+++ 13,
+++ 12,
+++ 7,
+++ 6,
+++ 5,
+++ 4,
+++ 11,
+++ 10,
+++ 9,
+++ 8,
+++ 3,
+++ 2,
+++ 1,
+++ 0,
+++ 15,
+++ 14,
+++ 13,
+++ 12,
+++ 7,
+++ 6,
+++ 5,
+++ 4,
+++ 11,
+++ 10,
+++ 9,
+++ 8,
+++ 3,
+++ 2,
+++ 1,
+++ 0);
+++
+++ for (number = 0; number < n32points; number++) {
+++ a0_val = _mm256_load_ps(aPtr);
+++ a1_val = _mm256_load_ps(aPtr + 8);
+++ a2_val = _mm256_load_ps(aPtr + 16);
+++ a3_val = _mm256_load_ps(aPtr + 24);
+++
+++ // compare >= 0; return float
+++ res0_f = _mm256_cmp_ps(a0_val, zero_val, _CMP_GE_OS);
+++ res1_f = _mm256_cmp_ps(a1_val, zero_val, _CMP_GE_OS);
+++ res2_f = _mm256_cmp_ps(a2_val, zero_val, _CMP_GE_OS);
+++ res3_f = _mm256_cmp_ps(a3_val, zero_val, _CMP_GE_OS);
+++
+++ // convert to 32i and >> 31
+++ res0_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res0_f), 31);
+++ res1_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res1_f), 31);
+++ res2_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res2_f), 31);
+++ res3_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res3_f), 31);
+++
+++ // pack in to 16-bit results
+++ res0_i = _mm256_packs_epi32(res0_i, res1_i);
+++ res2_i = _mm256_packs_epi32(res2_i, res3_i);
+++ // pack in to 8-bit results
+++ // res0: (after packs_epi32)
+++ // a0, a1, a2, a3, b0, b1, b2, b3, a4, a5, a6, a7, b4, b5, b6, b7
+++ // res2:
+++ // c0, c1, c2, c3, d0, d1, d2, d3, c4, c5, c6, c7, d4, d5, d6, d7
+++ res0_i = _mm256_packs_epi16(res0_i, res2_i);
+++ // shuffle the lanes
+++ // res0: (after packs_epi16)
+++ // a0, a1, a2, a3, b0, b1, b2, b3, c0, c1, c2, c3, d0, d1, d2, d3
+++ // a4, a5, a6, a7, b4, b5, b6, b7, c4, c5, c6, c7, d4, d5, d6, d7
+++ // 0, 2, 1, 3 -> 11 01 10 00 (0xd8)
+++ res0_i = _mm256_permute4x64_epi64(res0_i, 0xd8);
+++
+++ // shuffle bytes within lanes
+++ // res0: (after shuffle_epi8)
+++ // a0, a1, a2, a3, b0, b1, b2, b3, a4, a5, a6, a7, b4, b5, b6, b7
+++ // c0, c1, c2, c3, d0, d1, d2, d3, c4, c5, c6, c7, d4, d5, d6, d7
+++ res0_i = _mm256_shuffle_epi8(res0_i, byte_shuffle);
+++
+++ _mm256_store_si256((__m256i*)cPtr, res0_i);
+++ aPtr += 32;
+++ cPtr += 32;
++ }
++- else {
++- *cPtr++ = 0;
+++
+++ for (number = n32points * 32; number < num_points; number++) {
+++ if (*aPtr++ >= 0) {
+++ *cPtr++ = 1;
+++ } else {
+++ *cPtr++ = 0;
+++ }
++ }
++- }
++ }
++ #endif
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_binary_slicer_8i_u_avx2(int8_t* cVector, const float* aVector,
++- unsigned int num_points)
+++static inline void volk_32f_binary_slicer_8i_u_avx2(int8_t* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- int8_t* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++- unsigned int n32points = num_points / 32;
++-
++- const __m256 zero_val = _mm256_set1_ps(0.0f);
++- __m256 a0_val, a1_val, a2_val, a3_val;
++- __m256 res0_f, res1_f, res2_f, res3_f;
++- __m256i res0_i, res1_i, res2_i, res3_i;
++- __m256i byte_shuffle = _mm256_set_epi8( 15, 14, 13, 12, 7, 6, 5, 4,
++- 11, 10, 9, 8, 3, 2, 1, 0,
++- 15, 14, 13, 12, 7, 6, 5, 4,
++- 11, 10, 9, 8, 3, 2, 1, 0);
++-
++- for(number = 0; number < n32points; number++) {
++- a0_val = _mm256_loadu_ps(aPtr);
++- a1_val = _mm256_loadu_ps(aPtr+8);
++- a2_val = _mm256_loadu_ps(aPtr+16);
++- a3_val = _mm256_loadu_ps(aPtr+24);
++-
++- // compare >= 0; return float
++- res0_f = _mm256_cmp_ps(a0_val, zero_val, _CMP_GE_OS);
++- res1_f = _mm256_cmp_ps(a1_val, zero_val, _CMP_GE_OS);
++- res2_f = _mm256_cmp_ps(a2_val, zero_val, _CMP_GE_OS);
++- res3_f = _mm256_cmp_ps(a3_val, zero_val, _CMP_GE_OS);
++-
++- // convert to 32i and >> 31
++- res0_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res0_f), 31);
++- res1_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res1_f), 31);
++- res2_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res2_f), 31);
++- res3_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res3_f), 31);
++-
++- // pack in to 16-bit results
++- res0_i = _mm256_packs_epi32(res0_i, res1_i);
++- res2_i = _mm256_packs_epi32(res2_i, res3_i);
++- // pack in to 8-bit results
++- // res0: (after packs_epi32)
++- // a0, a1, a2, a3, b0, b1, b2, b3, a4, a5, a6, a7, b4, b5, b6, b7
++- // res2:
++- // c0, c1, c2, c3, d0, d1, d2, d3, c4, c5, c6, c7, d4, d5, d6, d7
++- res0_i = _mm256_packs_epi16(res0_i, res2_i);
++- // shuffle the lanes
++- // res0: (after packs_epi16)
++- // a0, a1, a2, a3, b0, b1, b2, b3, c0, c1, c2, c3, d0, d1, d2, d3
++- // a4, a5, a6, a7, b4, b5, b6, b7, c4, c5, c6, c7, d4, d5, d6, d7
++- // 0, 2, 1, 3 -> 11 01 10 00 (0xd8)
++- res0_i = _mm256_permute4x64_epi64(res0_i, 0xd8);
++-
++- // shuffle bytes within lanes
++- // res0: (after shuffle_epi8)
++- // a0, a1, a2, a3, b0, b1, b2, b3, a4, a5, a6, a7, b4, b5, b6, b7
++- // c0, c1, c2, c3, d0, d1, d2, d3, c4, c5, c6, c7, d4, d5, d6, d7
++- res0_i = _mm256_shuffle_epi8(res0_i, byte_shuffle);
++-
++- _mm256_storeu_si256((__m256i*)cPtr, res0_i);
++- aPtr += 32;
++- cPtr += 32;
++- }
++-
++- for(number = n32points * 32; number < num_points; number++) {
++- if( *aPtr++ >= 0) {
++- *cPtr++ = 1;
+++ int8_t* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
+++ unsigned int n32points = num_points / 32;
+++
+++ const __m256 zero_val = _mm256_set1_ps(0.0f);
+++ __m256 a0_val, a1_val, a2_val, a3_val;
+++ __m256 res0_f, res1_f, res2_f, res3_f;
+++ __m256i res0_i, res1_i, res2_i, res3_i;
+++ __m256i byte_shuffle = _mm256_set_epi8(15,
+++ 14,
+++ 13,
+++ 12,
+++ 7,
+++ 6,
+++ 5,
+++ 4,
+++ 11,
+++ 10,
+++ 9,
+++ 8,
+++ 3,
+++ 2,
+++ 1,
+++ 0,
+++ 15,
+++ 14,
+++ 13,
+++ 12,
+++ 7,
+++ 6,
+++ 5,
+++ 4,
+++ 11,
+++ 10,
+++ 9,
+++ 8,
+++ 3,
+++ 2,
+++ 1,
+++ 0);
+++
+++ for (number = 0; number < n32points; number++) {
+++ a0_val = _mm256_loadu_ps(aPtr);
+++ a1_val = _mm256_loadu_ps(aPtr + 8);
+++ a2_val = _mm256_loadu_ps(aPtr + 16);
+++ a3_val = _mm256_loadu_ps(aPtr + 24);
+++
+++ // compare >= 0; return float
+++ res0_f = _mm256_cmp_ps(a0_val, zero_val, _CMP_GE_OS);
+++ res1_f = _mm256_cmp_ps(a1_val, zero_val, _CMP_GE_OS);
+++ res2_f = _mm256_cmp_ps(a2_val, zero_val, _CMP_GE_OS);
+++ res3_f = _mm256_cmp_ps(a3_val, zero_val, _CMP_GE_OS);
+++
+++ // convert to 32i and >> 31
+++ res0_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res0_f), 31);
+++ res1_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res1_f), 31);
+++ res2_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res2_f), 31);
+++ res3_i = _mm256_srli_epi32(_mm256_cvtps_epi32(res3_f), 31);
+++
+++ // pack in to 16-bit results
+++ res0_i = _mm256_packs_epi32(res0_i, res1_i);
+++ res2_i = _mm256_packs_epi32(res2_i, res3_i);
+++ // pack in to 8-bit results
+++ // res0: (after packs_epi32)
+++ // a0, a1, a2, a3, b0, b1, b2, b3, a4, a5, a6, a7, b4, b5, b6, b7
+++ // res2:
+++ // c0, c1, c2, c3, d0, d1, d2, d3, c4, c5, c6, c7, d4, d5, d6, d7
+++ res0_i = _mm256_packs_epi16(res0_i, res2_i);
+++ // shuffle the lanes
+++ // res0: (after packs_epi16)
+++ // a0, a1, a2, a3, b0, b1, b2, b3, c0, c1, c2, c3, d0, d1, d2, d3
+++ // a4, a5, a6, a7, b4, b5, b6, b7, c4, c5, c6, c7, d4, d5, d6, d7
+++ // 0, 2, 1, 3 -> 11 01 10 00 (0xd8)
+++ res0_i = _mm256_permute4x64_epi64(res0_i, 0xd8);
+++
+++ // shuffle bytes within lanes
+++ // res0: (after shuffle_epi8)
+++ // a0, a1, a2, a3, b0, b1, b2, b3, a4, a5, a6, a7, b4, b5, b6, b7
+++ // c0, c1, c2, c3, d0, d1, d2, d3, c4, c5, c6, c7, d4, d5, d6, d7
+++ res0_i = _mm256_shuffle_epi8(res0_i, byte_shuffle);
+++
+++ _mm256_storeu_si256((__m256i*)cPtr, res0_i);
+++ aPtr += 32;
+++ cPtr += 32;
++ }
++- else {
++- *cPtr++ = 0;
+++
+++ for (number = n32points * 32; number < num_points; number++) {
+++ if (*aPtr++ >= 0) {
+++ *cPtr++ = 1;
+++ } else {
+++ *cPtr++ = 0;
+++ }
++ }
++- }
++ }
++ #endif
++
++
++-
++ #ifdef LV_HAVE_SSE2
++
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32f_binary_slicer_8i_a_sse2(int8_t* cVector, const float* aVector,
++- unsigned int num_points)
+++static inline void volk_32f_binary_slicer_8i_a_sse2(int8_t* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- int8_t* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++-
++- unsigned int n16points = num_points / 16;
++- __m128 a0_val, a1_val, a2_val, a3_val;
++- __m128 res0_f, res1_f, res2_f, res3_f;
++- __m128i res0_i, res1_i, res2_i, res3_i;
++- __m128 zero_val;
++- zero_val = _mm_set1_ps(0.0f);
++-
++- for(number = 0; number < n16points; number++) {
++- a0_val = _mm_load_ps(aPtr);
++- a1_val = _mm_load_ps(aPtr+4);
++- a2_val = _mm_load_ps(aPtr+8);
++- a3_val = _mm_load_ps(aPtr+12);
++-
++- // compare >= 0; return float
++- res0_f = _mm_cmpge_ps(a0_val, zero_val);
++- res1_f = _mm_cmpge_ps(a1_val, zero_val);
++- res2_f = _mm_cmpge_ps(a2_val, zero_val);
++- res3_f = _mm_cmpge_ps(a3_val, zero_val);
++-
++- // convert to 32i and >> 31
++- res0_i = _mm_srli_epi32(_mm_cvtps_epi32(res0_f), 31);
++- res1_i = _mm_srli_epi32(_mm_cvtps_epi32(res1_f), 31);
++- res2_i = _mm_srli_epi32(_mm_cvtps_epi32(res2_f), 31);
++- res3_i = _mm_srli_epi32(_mm_cvtps_epi32(res3_f), 31);
++-
++- // pack into 16-bit results
++- res0_i = _mm_packs_epi32(res0_i, res1_i);
++- res2_i = _mm_packs_epi32(res2_i, res3_i);
++-
++- // pack into 8-bit results
++- res0_i = _mm_packs_epi16(res0_i, res2_i);
++-
++- _mm_store_si128((__m128i*)cPtr, res0_i);
++-
++- cPtr += 16;
++- aPtr += 16;
++- }
++-
++- for(number = n16points * 16; number < num_points; number++) {
++- if( *aPtr++ >= 0) {
++- *cPtr++ = 1;
+++ int8_t* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
+++
+++ unsigned int n16points = num_points / 16;
+++ __m128 a0_val, a1_val, a2_val, a3_val;
+++ __m128 res0_f, res1_f, res2_f, res3_f;
+++ __m128i res0_i, res1_i, res2_i, res3_i;
+++ __m128 zero_val;
+++ zero_val = _mm_set1_ps(0.0f);
+++
+++ for (number = 0; number < n16points; number++) {
+++ a0_val = _mm_load_ps(aPtr);
+++ a1_val = _mm_load_ps(aPtr + 4);
+++ a2_val = _mm_load_ps(aPtr + 8);
+++ a3_val = _mm_load_ps(aPtr + 12);
+++
+++ // compare >= 0; return float
+++ res0_f = _mm_cmpge_ps(a0_val, zero_val);
+++ res1_f = _mm_cmpge_ps(a1_val, zero_val);
+++ res2_f = _mm_cmpge_ps(a2_val, zero_val);
+++ res3_f = _mm_cmpge_ps(a3_val, zero_val);
+++
+++ // convert to 32i and >> 31
+++ res0_i = _mm_srli_epi32(_mm_cvtps_epi32(res0_f), 31);
+++ res1_i = _mm_srli_epi32(_mm_cvtps_epi32(res1_f), 31);
+++ res2_i = _mm_srli_epi32(_mm_cvtps_epi32(res2_f), 31);
+++ res3_i = _mm_srli_epi32(_mm_cvtps_epi32(res3_f), 31);
+++
+++ // pack into 16-bit results
+++ res0_i = _mm_packs_epi32(res0_i, res1_i);
+++ res2_i = _mm_packs_epi32(res2_i, res3_i);
+++
+++ // pack into 8-bit results
+++ res0_i = _mm_packs_epi16(res0_i, res2_i);
+++
+++ _mm_store_si128((__m128i*)cPtr, res0_i);
+++
+++ cPtr += 16;
+++ aPtr += 16;
++ }
++- else {
++- *cPtr++ = 0;
+++
+++ for (number = n16points * 16; number < num_points; number++) {
+++ if (*aPtr++ >= 0) {
+++ *cPtr++ = 1;
+++ } else {
+++ *cPtr++ = 0;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++
++-
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32f_binary_slicer_8i_u_sse2(int8_t* cVector, const float* aVector,
++- unsigned int num_points)
+++static inline void volk_32f_binary_slicer_8i_u_sse2(int8_t* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- int8_t* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++-
++- unsigned int n16points = num_points / 16;
++- __m128 a0_val, a1_val, a2_val, a3_val;
++- __m128 res0_f, res1_f, res2_f, res3_f;
++- __m128i res0_i, res1_i, res2_i, res3_i;
++- __m128 zero_val;
++- zero_val = _mm_set1_ps (0.0f);
++-
++- for(number = 0; number < n16points; number++) {
++- a0_val = _mm_loadu_ps(aPtr);
++- a1_val = _mm_loadu_ps(aPtr+4);
++- a2_val = _mm_loadu_ps(aPtr+8);
++- a3_val = _mm_loadu_ps(aPtr+12);
++-
++- // compare >= 0; return float
++- res0_f = _mm_cmpge_ps(a0_val, zero_val);
++- res1_f = _mm_cmpge_ps(a1_val, zero_val);
++- res2_f = _mm_cmpge_ps(a2_val, zero_val);
++- res3_f = _mm_cmpge_ps(a3_val, zero_val);
++-
++- // convert to 32i and >> 31
++- res0_i = _mm_srli_epi32(_mm_cvtps_epi32(res0_f), 31);
++- res1_i = _mm_srli_epi32(_mm_cvtps_epi32(res1_f), 31);
++- res2_i = _mm_srli_epi32(_mm_cvtps_epi32(res2_f), 31);
++- res3_i = _mm_srli_epi32(_mm_cvtps_epi32(res3_f), 31);
++-
++- // pack into 16-bit results
++- res0_i = _mm_packs_epi32(res0_i, res1_i);
++- res2_i = _mm_packs_epi32(res2_i, res3_i);
++-
++- // pack into 8-bit results
++- res0_i = _mm_packs_epi16(res0_i, res2_i);
++-
++- _mm_storeu_si128((__m128i*)cPtr, res0_i);
++-
++- cPtr += 16;
++- aPtr += 16;
++- }
++-
++- for(number = n16points * 16; number < num_points; number++) {
++- if( *aPtr++ >= 0) {
++- *cPtr++ = 1;
+++ int8_t* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
+++
+++ unsigned int n16points = num_points / 16;
+++ __m128 a0_val, a1_val, a2_val, a3_val;
+++ __m128 res0_f, res1_f, res2_f, res3_f;
+++ __m128i res0_i, res1_i, res2_i, res3_i;
+++ __m128 zero_val;
+++ zero_val = _mm_set1_ps(0.0f);
+++
+++ for (number = 0; number < n16points; number++) {
+++ a0_val = _mm_loadu_ps(aPtr);
+++ a1_val = _mm_loadu_ps(aPtr + 4);
+++ a2_val = _mm_loadu_ps(aPtr + 8);
+++ a3_val = _mm_loadu_ps(aPtr + 12);
+++
+++ // compare >= 0; return float
+++ res0_f = _mm_cmpge_ps(a0_val, zero_val);
+++ res1_f = _mm_cmpge_ps(a1_val, zero_val);
+++ res2_f = _mm_cmpge_ps(a2_val, zero_val);
+++ res3_f = _mm_cmpge_ps(a3_val, zero_val);
+++
+++ // convert to 32i and >> 31
+++ res0_i = _mm_srli_epi32(_mm_cvtps_epi32(res0_f), 31);
+++ res1_i = _mm_srli_epi32(_mm_cvtps_epi32(res1_f), 31);
+++ res2_i = _mm_srli_epi32(_mm_cvtps_epi32(res2_f), 31);
+++ res3_i = _mm_srli_epi32(_mm_cvtps_epi32(res3_f), 31);
+++
+++ // pack into 16-bit results
+++ res0_i = _mm_packs_epi32(res0_i, res1_i);
+++ res2_i = _mm_packs_epi32(res2_i, res3_i);
+++
+++ // pack into 8-bit results
+++ res0_i = _mm_packs_epi16(res0_i, res2_i);
+++
+++ _mm_storeu_si128((__m128i*)cPtr, res0_i);
+++
+++ cPtr += 16;
+++ aPtr += 16;
++ }
++- else {
++- *cPtr++ = 0;
+++
+++ for (number = n16points * 16; number < num_points; number++) {
+++ if (*aPtr++ >= 0) {
+++ *cPtr++ = 1;
+++ } else {
+++ *cPtr++ = 0;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++@@ -394,74 +444,72 @@ volk_32f_binary_slicer_8i_u_sse2(int8_t* cVector, const float* aVector,
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32f_binary_slicer_8i_neon(int8_t* cVector, const float* aVector,
++- unsigned int num_points)
+++static inline void volk_32f_binary_slicer_8i_neon(int8_t* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- int8_t* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++- unsigned int n16points = num_points / 16;
++-
++- float32x4x2_t input_val0, input_val1;
++- float32x4_t zero_val;
++- uint32x4x2_t res0_u32, res1_u32;
++- uint16x4x2_t res0_u16x4, res1_u16x4;
++- uint16x8x2_t res_u16x8;
++- uint8x8x2_t res_u8;
++- uint8x8_t one;
++-
++- zero_val = vdupq_n_f32(0.0);
++- one = vdup_n_u8(0x01);
++-
++- // TODO: this is a good candidate for asm because the vcombines
++- // can be eliminated simply by picking dst registers that are
++- // adjacent.
++- for(number = 0; number < n16points; number++) {
++- input_val0 = vld2q_f32(aPtr);
++- input_val1 = vld2q_f32(aPtr+8);
++-
++- // test against 0; return uint32
++- res0_u32.val[0] = vcgeq_f32(input_val0.val[0], zero_val);
++- res0_u32.val[1] = vcgeq_f32(input_val0.val[1], zero_val);
++- res1_u32.val[0] = vcgeq_f32(input_val1.val[0], zero_val);
++- res1_u32.val[1] = vcgeq_f32(input_val1.val[1], zero_val);
++-
++- // narrow uint32 -> uint16 followed by combine to 8-element vectors
++- res0_u16x4.val[0] = vmovn_u32(res0_u32.val[0]);
++- res0_u16x4.val[1] = vmovn_u32(res0_u32.val[1]);
++- res1_u16x4.val[0] = vmovn_u32(res1_u32.val[0]);
++- res1_u16x4.val[1] = vmovn_u32(res1_u32.val[1]);
++-
++- res_u16x8.val[0] = vcombine_u16(res0_u16x4.val[0], res1_u16x4.val[0]);
++- res_u16x8.val[1] = vcombine_u16(res0_u16x4.val[1], res1_u16x4.val[1]);
++-
++- // narrow uint16x8 -> uint8x8
++- res_u8.val[0] = vmovn_u16(res_u16x8.val[0]);
++- res_u8.val[1] = vmovn_u16(res_u16x8.val[1]);
++- // we *could* load twice as much data and do another vcombine here
++- // to get a uint8x16x2 vector, still only do 2 vandqs and a single store
++- // but that turns out to be ~16% slower than this version on zc702
++- // it's possible register contention in GCC scheduler slows it down
++- // and a hand-written asm with quad-word u8 registers is much faster.
++-
++- res_u8.val[0] = vand_u8(one, res_u8.val[0]);
++- res_u8.val[1] = vand_u8(one, res_u8.val[1]);
++-
++- vst2_u8((unsigned char*)cPtr, res_u8);
++- cPtr += 16;
++- aPtr += 16;
++-
++- }
++-
++- for(number = n16points * 16; number < num_points; number++) {
++- if(*aPtr++ >= 0) {
++- *cPtr++ = 1;
+++ int8_t* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
+++ unsigned int n16points = num_points / 16;
+++
+++ float32x4x2_t input_val0, input_val1;
+++ float32x4_t zero_val;
+++ uint32x4x2_t res0_u32, res1_u32;
+++ uint16x4x2_t res0_u16x4, res1_u16x4;
+++ uint16x8x2_t res_u16x8;
+++ uint8x8x2_t res_u8;
+++ uint8x8_t one;
+++
+++ zero_val = vdupq_n_f32(0.0);
+++ one = vdup_n_u8(0x01);
+++
+++ // TODO: this is a good candidate for asm because the vcombines
+++ // can be eliminated simply by picking dst registers that are
+++ // adjacent.
+++ for (number = 0; number < n16points; number++) {
+++ input_val0 = vld2q_f32(aPtr);
+++ input_val1 = vld2q_f32(aPtr + 8);
+++
+++ // test against 0; return uint32
+++ res0_u32.val[0] = vcgeq_f32(input_val0.val[0], zero_val);
+++ res0_u32.val[1] = vcgeq_f32(input_val0.val[1], zero_val);
+++ res1_u32.val[0] = vcgeq_f32(input_val1.val[0], zero_val);
+++ res1_u32.val[1] = vcgeq_f32(input_val1.val[1], zero_val);
+++
+++ // narrow uint32 -> uint16 followed by combine to 8-element vectors
+++ res0_u16x4.val[0] = vmovn_u32(res0_u32.val[0]);
+++ res0_u16x4.val[1] = vmovn_u32(res0_u32.val[1]);
+++ res1_u16x4.val[0] = vmovn_u32(res1_u32.val[0]);
+++ res1_u16x4.val[1] = vmovn_u32(res1_u32.val[1]);
+++
+++ res_u16x8.val[0] = vcombine_u16(res0_u16x4.val[0], res1_u16x4.val[0]);
+++ res_u16x8.val[1] = vcombine_u16(res0_u16x4.val[1], res1_u16x4.val[1]);
+++
+++ // narrow uint16x8 -> uint8x8
+++ res_u8.val[0] = vmovn_u16(res_u16x8.val[0]);
+++ res_u8.val[1] = vmovn_u16(res_u16x8.val[1]);
+++ // we *could* load twice as much data and do another vcombine here
+++ // to get a uint8x16x2 vector, still only do 2 vandqs and a single store
+++ // but that turns out to be ~16% slower than this version on zc702
+++ // it's possible register contention in GCC scheduler slows it down
+++ // and a hand-written asm with quad-word u8 registers is much faster.
+++
+++ res_u8.val[0] = vand_u8(one, res_u8.val[0]);
+++ res_u8.val[1] = vand_u8(one, res_u8.val[1]);
+++
+++ vst2_u8((unsigned char*)cPtr, res_u8);
+++ cPtr += 16;
+++ aPtr += 16;
++ }
++- else {
++- *cPtr++ = 0;
+++
+++ for (number = n16points * 16; number < num_points; number++) {
+++ if (*aPtr++ >= 0) {
+++ *cPtr++ = 1;
+++ } else {
+++ *cPtr++ = 0;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_NEON */
++
++diff --git a/kernels/volk/volk_32f_convert_64f.h b/kernels/volk/volk_32f_convert_64f.h
++index bf57e3a..d2e3f8a 100644
++--- a/kernels/volk/volk_32f_convert_64f.h
+++++ b/kernels/volk/volk_32f_convert_64f.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_convert_64f(double* outputVector, const float* inputVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_convert_64f(double* outputVector, const float* inputVector, unsigned int
+++ * num_points) \endcode
++ *
++ * \b Inputs
++ * \li inputVector: The vector of floats to convert to doubles.
++@@ -72,29 +72,33 @@
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32f_convert_64f_u_avx(double* outputVector, const float* inputVector, unsigned int num_points){
++- unsigned int number = 0;
+++static inline void volk_32f_convert_64f_u_avx(double* outputVector,
+++ const float* inputVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
++
++- const unsigned int quarterPoints = num_points / 4;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* inputVectorPtr = (const float*)inputVector;
++- double* outputVectorPtr = outputVector;
++- __m256d ret;
++- __m128 inputVal;
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ double* outputVectorPtr = outputVector;
+++ __m256d ret;
+++ __m128 inputVal;
++
++- for(;number < quarterPoints; number++){
++- inputVal = _mm_loadu_ps(inputVectorPtr); inputVectorPtr += 4;
+++ for (; number < quarterPoints; number++) {
+++ inputVal = _mm_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
++
++- ret = _mm256_cvtps_pd(inputVal);
++- _mm256_storeu_pd(outputVectorPtr, ret);
+++ ret = _mm256_cvtps_pd(inputVal);
+++ _mm256_storeu_pd(outputVectorPtr, ret);
++
++- outputVectorPtr += 4;
++- }
+++ outputVectorPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- outputVector[number] = (double)(inputVector[number]);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (double)(inputVector[number]);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++@@ -102,56 +106,61 @@ static inline void volk_32f_convert_64f_u_avx(double* outputVector, const float*
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_32f_convert_64f_u_sse2(double* outputVector, const float* inputVector, unsigned int num_points){
++- unsigned int number = 0;
+++static inline void volk_32f_convert_64f_u_sse2(double* outputVector,
+++ const float* inputVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
++
++- const unsigned int quarterPoints = num_points / 4;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* inputVectorPtr = (const float*)inputVector;
++- double* outputVectorPtr = outputVector;
++- __m128d ret;
++- __m128 inputVal;
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ double* outputVectorPtr = outputVector;
+++ __m128d ret;
+++ __m128 inputVal;
++
++- for(;number < quarterPoints; number++){
++- inputVal = _mm_loadu_ps(inputVectorPtr); inputVectorPtr += 4;
+++ for (; number < quarterPoints; number++) {
+++ inputVal = _mm_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
++
++- ret = _mm_cvtps_pd(inputVal);
+++ ret = _mm_cvtps_pd(inputVal);
++
++- _mm_storeu_pd(outputVectorPtr, ret);
++- outputVectorPtr += 2;
+++ _mm_storeu_pd(outputVectorPtr, ret);
+++ outputVectorPtr += 2;
++
++- inputVal = _mm_movehl_ps(inputVal, inputVal);
+++ inputVal = _mm_movehl_ps(inputVal, inputVal);
++
++- ret = _mm_cvtps_pd(inputVal);
+++ ret = _mm_cvtps_pd(inputVal);
++
++- _mm_storeu_pd(outputVectorPtr, ret);
++- outputVectorPtr += 2;
++- }
+++ _mm_storeu_pd(outputVectorPtr, ret);
+++ outputVectorPtr += 2;
+++ }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- outputVector[number] = (double)(inputVector[number]);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (double)(inputVector[number]);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32f_convert_64f_generic(double* outputVector, const float* inputVector, unsigned int num_points){
++- double* outputVectorPtr = outputVector;
++- const float* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((double)(*inputVectorPtr++));
++- }
+++static inline void volk_32f_convert_64f_generic(double* outputVector,
+++ const float* inputVector,
+++ unsigned int num_points)
+++{
+++ double* outputVectorPtr = outputVector;
+++ const float* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((double)(*inputVectorPtr++));
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++-
++ #endif /* INCLUDED_volk_32f_convert_64f_u_H */
++
++
++@@ -164,83 +173,92 @@ static inline void volk_32f_convert_64f_generic(double* outputVector, const floa
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32f_convert_64f_a_avx(double* outputVector, const float* inputVector, unsigned int num_points){
++- unsigned int number = 0;
+++static inline void volk_32f_convert_64f_a_avx(double* outputVector,
+++ const float* inputVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
++
++- const unsigned int quarterPoints = num_points / 4;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* inputVectorPtr = (const float*)inputVector;
++- double* outputVectorPtr = outputVector;
++- __m256d ret;
++- __m128 inputVal;
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ double* outputVectorPtr = outputVector;
+++ __m256d ret;
+++ __m128 inputVal;
++
++- for(;number < quarterPoints; number++){
++- inputVal = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;
+++ for (; number < quarterPoints; number++) {
+++ inputVal = _mm_load_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
++
++- ret = _mm256_cvtps_pd(inputVal);
++- _mm256_store_pd(outputVectorPtr, ret);
+++ ret = _mm256_cvtps_pd(inputVal);
+++ _mm256_store_pd(outputVectorPtr, ret);
++
++- outputVectorPtr += 4;
++- }
+++ outputVectorPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- outputVector[number] = (double)(inputVector[number]);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (double)(inputVector[number]);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_32f_convert_64f_a_sse2(double* outputVector, const float* inputVector, unsigned int num_points){
++- unsigned int number = 0;
+++static inline void volk_32f_convert_64f_a_sse2(double* outputVector,
+++ const float* inputVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
++
++- const unsigned int quarterPoints = num_points / 4;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* inputVectorPtr = (const float*)inputVector;
++- double* outputVectorPtr = outputVector;
++- __m128d ret;
++- __m128 inputVal;
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ double* outputVectorPtr = outputVector;
+++ __m128d ret;
+++ __m128 inputVal;
++
++- for(;number < quarterPoints; number++){
++- inputVal = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;
+++ for (; number < quarterPoints; number++) {
+++ inputVal = _mm_load_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
++
++- ret = _mm_cvtps_pd(inputVal);
+++ ret = _mm_cvtps_pd(inputVal);
++
++- _mm_store_pd(outputVectorPtr, ret);
++- outputVectorPtr += 2;
+++ _mm_store_pd(outputVectorPtr, ret);
+++ outputVectorPtr += 2;
++
++- inputVal = _mm_movehl_ps(inputVal, inputVal);
+++ inputVal = _mm_movehl_ps(inputVal, inputVal);
++
++- ret = _mm_cvtps_pd(inputVal);
+++ ret = _mm_cvtps_pd(inputVal);
++
++- _mm_store_pd(outputVectorPtr, ret);
++- outputVectorPtr += 2;
++- }
+++ _mm_store_pd(outputVectorPtr, ret);
+++ outputVectorPtr += 2;
+++ }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- outputVector[number] = (double)(inputVector[number]);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (double)(inputVector[number]);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32f_convert_64f_a_generic(double* outputVector, const float* inputVector, unsigned int num_points){
++- double* outputVectorPtr = outputVector;
++- const float* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((double)(*inputVectorPtr++));
++- }
+++static inline void volk_32f_convert_64f_a_generic(double* outputVector,
+++ const float* inputVector,
+++ unsigned int num_points)
+++{
+++ double* outputVectorPtr = outputVector;
+++ const float* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((double)(*inputVectorPtr++));
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++-
++ #endif /* INCLUDED_volk_32f_convert_64f_a_H */
++diff --git a/kernels/volk/volk_32f_cos_32f.h b/kernels/volk/volk_32f_cos_32f.h
++index 39c2008..b493764 100644
++--- a/kernels/volk/volk_32f_cos_32f.h
+++++ b/kernels/volk/volk_32f_cos_32f.h
++@@ -69,9 +69,9 @@
++ * \endcode
++ */
++
++-#include <stdio.h>
++-#include <math.h>
++ #include <inttypes.h>
+++#include <math.h>
+++#include <stdio.h>
++
++ #ifndef INCLUDED_volk_32f_cos_32f_a_H
++ #define INCLUDED_volk_32f_cos_32f_a_H
++@@ -80,86 +80,102 @@
++ #include <immintrin.h>
++
++ static inline void
++- volk_32f_cos_32f_a_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
+++volk_32f_cos_32f_a_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- unsigned int i = 0;
++-
++- __m256 aVal, s, r, m4pi, pio4A, pio4B, pio4C, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m256 sine, cosine;
++- __m256i q, ones, twos, fours;
++-
++- m4pi = _mm256_set1_ps(1.273239544735162542821171882678754627704620361328125);
++- pio4A = _mm256_set1_ps(0.7853981554508209228515625);
++- pio4B = _mm256_set1_ps(0.794662735614792836713604629039764404296875e-8);
++- pio4C = _mm256_set1_ps(0.306161699786838294306516483068750264552437361480769e-16);
++- ffours = _mm256_set1_ps(4.0);
++- ftwos = _mm256_set1_ps(2.0);
++- fones = _mm256_set1_ps(1.0);
++- fzeroes = _mm256_setzero_ps();
++- __m256i zeroes = _mm256_set1_epi32(0);
++- ones = _mm256_set1_epi32(1);
++- __m256i allones = _mm256_set1_epi32(0xffffffff);
++- twos = _mm256_set1_epi32(2);
++- fours = _mm256_set1_epi32(4);
++-
++- cp1 = _mm256_set1_ps(1.0);
++- cp2 = _mm256_set1_ps(0.08333333333333333);
++- cp3 = _mm256_set1_ps(0.002777777777777778);
++- cp4 = _mm256_set1_ps(4.96031746031746e-05);
++- cp5 = _mm256_set1_ps(5.511463844797178e-07);
++- union bit256 condition1;
++- union bit256 condition3;
++-
++- for(;number < eighthPoints; number++){
++-
++- aVal = _mm256_load_ps(aPtr);
++- // s = fabs(aVal)
++- s = _mm256_sub_ps(aVal, _mm256_and_ps(_mm256_mul_ps(aVal, ftwos), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
++- // q = (int) (s * (4/pi)), floor(aVal / (pi/4))
++- q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
++- // r = q + q&1, q indicates quadrant, r gives
++- r = _mm256_cvtepi32_ps(_mm256_add_epi32(q, _mm256_and_si256(q, ones)));
++-
++- s = _mm256_fnmadd_ps(r,pio4A,s);
++- s = _mm256_fnmadd_ps(r,pio4B,s);
++- s = _mm256_fnmadd_ps(r,pio4C,s);
++-
++- s = _mm256_div_ps(s, _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm256_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm256_mul_ps(_mm256_fmadd_ps(_mm256_fmsub_ps(_mm256_fmadd_ps(_mm256_fmsub_ps(s, cp5, cp4), s, cp3), s, cp2), s, cp1), s);
++-
++- for(i = 0; i < 3; i++)
++- s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
++- s = _mm256_div_ps(s, ftwos);
++-
++- sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
++- cosine = _mm256_sub_ps(fones, s);
++-
++- // if(((q+1)&2) != 0) { cosine=sine;}
++- condition1.int_vec = _mm256_cmpeq_epi32(_mm256_and_si256(_mm256_add_epi32(q, ones), twos), zeroes);
++- condition1.int_vec = _mm256_xor_si256(allones, condition1.int_vec);
++-
++- // if(((q+2)&4) != 0) { cosine = -cosine;}
++- condition3.int_vec = _mm256_cmpeq_epi32(_mm256_and_si256(_mm256_add_epi32(q, twos), fours), zeroes);
++- condition3.int_vec = _mm256_xor_si256(allones, condition3.int_vec);
++-
++- cosine = _mm256_add_ps(cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1.float_vec));
++- cosine = _mm256_sub_ps(cosine, _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)), condition3.float_vec));
++- _mm256_store_ps(bPtr, cosine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = cos(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ unsigned int i = 0;
+++
+++ __m256 aVal, s, r, m4pi, pio4A, pio4B, pio4C, cp1, cp2, cp3, cp4, cp5, ffours, ftwos,
+++ fones, fzeroes;
+++ __m256 sine, cosine;
+++ __m256i q, ones, twos, fours;
+++
+++ m4pi = _mm256_set1_ps(1.273239544735162542821171882678754627704620361328125);
+++ pio4A = _mm256_set1_ps(0.7853981554508209228515625);
+++ pio4B = _mm256_set1_ps(0.794662735614792836713604629039764404296875e-8);
+++ pio4C = _mm256_set1_ps(0.306161699786838294306516483068750264552437361480769e-16);
+++ ffours = _mm256_set1_ps(4.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ fones = _mm256_set1_ps(1.0);
+++ fzeroes = _mm256_setzero_ps();
+++ __m256i zeroes = _mm256_set1_epi32(0);
+++ ones = _mm256_set1_epi32(1);
+++ __m256i allones = _mm256_set1_epi32(0xffffffff);
+++ twos = _mm256_set1_epi32(2);
+++ fours = _mm256_set1_epi32(4);
+++
+++ cp1 = _mm256_set1_ps(1.0);
+++ cp2 = _mm256_set1_ps(0.08333333333333333);
+++ cp3 = _mm256_set1_ps(0.002777777777777778);
+++ cp4 = _mm256_set1_ps(4.96031746031746e-05);
+++ cp5 = _mm256_set1_ps(5.511463844797178e-07);
+++ union bit256 condition1;
+++ union bit256 condition3;
+++
+++ for (; number < eighthPoints; number++) {
+++
+++ aVal = _mm256_load_ps(aPtr);
+++ // s = fabs(aVal)
+++ s = _mm256_sub_ps(aVal,
+++ _mm256_and_ps(_mm256_mul_ps(aVal, ftwos),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
+++ // q = (int) (s * (4/pi)), floor(aVal / (pi/4))
+++ q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
+++ // r = q + q&1, q indicates quadrant, r gives
+++ r = _mm256_cvtepi32_ps(_mm256_add_epi32(q, _mm256_and_si256(q, ones)));
+++
+++ s = _mm256_fnmadd_ps(r, pio4A, s);
+++ s = _mm256_fnmadd_ps(r, pio4B, s);
+++ s = _mm256_fnmadd_ps(r, pio4C, s);
+++
+++ s = _mm256_div_ps(
+++ s,
+++ _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm256_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm256_mul_ps(
+++ _mm256_fmadd_ps(
+++ _mm256_fmsub_ps(
+++ _mm256_fmadd_ps(_mm256_fmsub_ps(s, cp5, cp4), s, cp3), s, cp2),
+++ s,
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++)
+++ s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ s = _mm256_div_ps(s, ftwos);
+++
+++ sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
+++ cosine = _mm256_sub_ps(fones, s);
+++
+++ // if(((q+1)&2) != 0) { cosine=sine;}
+++ condition1.int_vec =
+++ _mm256_cmpeq_epi32(_mm256_and_si256(_mm256_add_epi32(q, ones), twos), zeroes);
+++ condition1.int_vec = _mm256_xor_si256(allones, condition1.int_vec);
+++
+++ // if(((q+2)&4) != 0) { cosine = -cosine;}
+++ condition3.int_vec = _mm256_cmpeq_epi32(
+++ _mm256_and_si256(_mm256_add_epi32(q, twos), fours), zeroes);
+++ condition3.int_vec = _mm256_xor_si256(allones, condition3.int_vec);
+++
+++ cosine = _mm256_add_ps(
+++ cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1.float_vec));
+++ cosine = _mm256_sub_ps(cosine,
+++ _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)),
+++ condition3.float_vec));
+++ _mm256_store_ps(bPtr, cosine);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = cos(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for aligned */
++@@ -168,86 +184,109 @@ static inline void
++ #include <immintrin.h>
++
++ static inline void
++- volk_32f_cos_32f_a_avx2(float* bVector, const float* aVector, unsigned int num_points)
+++volk_32f_cos_32f_a_avx2(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- unsigned int i = 0;
++-
++- __m256 aVal, s, r, m4pi, pio4A, pio4B, pio4C, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m256 sine, cosine;
++- __m256i q, ones, twos, fours;
++-
++- m4pi = _mm256_set1_ps(1.273239544735162542821171882678754627704620361328125);
++- pio4A = _mm256_set1_ps(0.7853981554508209228515625);
++- pio4B = _mm256_set1_ps(0.794662735614792836713604629039764404296875e-8);
++- pio4C = _mm256_set1_ps(0.306161699786838294306516483068750264552437361480769e-16);
++- ffours = _mm256_set1_ps(4.0);
++- ftwos = _mm256_set1_ps(2.0);
++- fones = _mm256_set1_ps(1.0);
++- fzeroes = _mm256_setzero_ps();
++- __m256i zeroes = _mm256_set1_epi32(0);
++- ones = _mm256_set1_epi32(1);
++- __m256i allones = _mm256_set1_epi32(0xffffffff);
++- twos = _mm256_set1_epi32(2);
++- fours = _mm256_set1_epi32(4);
++-
++- cp1 = _mm256_set1_ps(1.0);
++- cp2 = _mm256_set1_ps(0.08333333333333333);
++- cp3 = _mm256_set1_ps(0.002777777777777778);
++- cp4 = _mm256_set1_ps(4.96031746031746e-05);
++- cp5 = _mm256_set1_ps(5.511463844797178e-07);
++- union bit256 condition1;
++- union bit256 condition3;
++-
++- for(;number < eighthPoints; number++){
++-
++- aVal = _mm256_load_ps(aPtr);
++- // s = fabs(aVal)
++- s = _mm256_sub_ps(aVal, _mm256_and_ps(_mm256_mul_ps(aVal, ftwos), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
++- // q = (int) (s * (4/pi)), floor(aVal / (pi/4))
++- q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
++- // r = q + q&1, q indicates quadrant, r gives
++- r = _mm256_cvtepi32_ps(_mm256_add_epi32(q, _mm256_and_si256(q, ones)));
++-
++- s = _mm256_sub_ps(s, _mm256_mul_ps(r,pio4A));
++- s = _mm256_sub_ps(s, _mm256_mul_ps(r,pio4B));
++- s = _mm256_sub_ps(s, _mm256_mul_ps(r,pio4C));
++-
++- s = _mm256_div_ps(s, _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm256_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm256_mul_ps(_mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(_mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
++-
++- for(i = 0; i < 3; i++)
++- s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
++- s = _mm256_div_ps(s, ftwos);
++-
++- sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
++- cosine = _mm256_sub_ps(fones, s);
++-
++- // if(((q+1)&2) != 0) { cosine=sine;}
++- condition1.int_vec = _mm256_cmpeq_epi32(_mm256_and_si256(_mm256_add_epi32(q, ones), twos), zeroes);
++- condition1.int_vec = _mm256_xor_si256(allones, condition1.int_vec);
++-
++- // if(((q+2)&4) != 0) { cosine = -cosine;}
++- condition3.int_vec = _mm256_cmpeq_epi32(_mm256_and_si256(_mm256_add_epi32(q, twos), fours), zeroes);
++- condition3.int_vec = _mm256_xor_si256(allones, condition3.int_vec);
++-
++- cosine = _mm256_add_ps(cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1.float_vec));
++- cosine = _mm256_sub_ps(cosine, _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)), condition3.float_vec));
++- _mm256_store_ps(bPtr, cosine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = cos(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ unsigned int i = 0;
+++
+++ __m256 aVal, s, r, m4pi, pio4A, pio4B, pio4C, cp1, cp2, cp3, cp4, cp5, ffours, ftwos,
+++ fones, fzeroes;
+++ __m256 sine, cosine;
+++ __m256i q, ones, twos, fours;
+++
+++ m4pi = _mm256_set1_ps(1.273239544735162542821171882678754627704620361328125);
+++ pio4A = _mm256_set1_ps(0.7853981554508209228515625);
+++ pio4B = _mm256_set1_ps(0.794662735614792836713604629039764404296875e-8);
+++ pio4C = _mm256_set1_ps(0.306161699786838294306516483068750264552437361480769e-16);
+++ ffours = _mm256_set1_ps(4.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ fones = _mm256_set1_ps(1.0);
+++ fzeroes = _mm256_setzero_ps();
+++ __m256i zeroes = _mm256_set1_epi32(0);
+++ ones = _mm256_set1_epi32(1);
+++ __m256i allones = _mm256_set1_epi32(0xffffffff);
+++ twos = _mm256_set1_epi32(2);
+++ fours = _mm256_set1_epi32(4);
+++
+++ cp1 = _mm256_set1_ps(1.0);
+++ cp2 = _mm256_set1_ps(0.08333333333333333);
+++ cp3 = _mm256_set1_ps(0.002777777777777778);
+++ cp4 = _mm256_set1_ps(4.96031746031746e-05);
+++ cp5 = _mm256_set1_ps(5.511463844797178e-07);
+++ union bit256 condition1;
+++ union bit256 condition3;
+++
+++ for (; number < eighthPoints; number++) {
+++
+++ aVal = _mm256_load_ps(aPtr);
+++ // s = fabs(aVal)
+++ s = _mm256_sub_ps(aVal,
+++ _mm256_and_ps(_mm256_mul_ps(aVal, ftwos),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
+++ // q = (int) (s * (4/pi)), floor(aVal / (pi/4))
+++ q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
+++ // r = q + q&1, q indicates quadrant, r gives
+++ r = _mm256_cvtepi32_ps(_mm256_add_epi32(q, _mm256_and_si256(q, ones)));
+++
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(r, pio4A));
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(r, pio4B));
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(r, pio4C));
+++
+++ s = _mm256_div_ps(
+++ s,
+++ _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm256_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm256_mul_ps(
+++ _mm256_add_ps(
+++ _mm256_mul_ps(
+++ _mm256_sub_ps(
+++ _mm256_mul_ps(
+++ _mm256_add_ps(
+++ _mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(s, cp5), cp4),
+++ s),
+++ cp3),
+++ s),
+++ cp2),
+++ s),
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++)
+++ s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ s = _mm256_div_ps(s, ftwos);
+++
+++ sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
+++ cosine = _mm256_sub_ps(fones, s);
+++
+++ // if(((q+1)&2) != 0) { cosine=sine;}
+++ condition1.int_vec =
+++ _mm256_cmpeq_epi32(_mm256_and_si256(_mm256_add_epi32(q, ones), twos), zeroes);
+++ condition1.int_vec = _mm256_xor_si256(allones, condition1.int_vec);
+++
+++ // if(((q+2)&4) != 0) { cosine = -cosine;}
+++ condition3.int_vec = _mm256_cmpeq_epi32(
+++ _mm256_and_si256(_mm256_add_epi32(q, twos), fours), zeroes);
+++ condition3.int_vec = _mm256_xor_si256(allones, condition3.int_vec);
+++
+++ cosine = _mm256_add_ps(
+++ cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1.float_vec));
+++ cosine = _mm256_sub_ps(cosine,
+++ _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)),
+++ condition3.float_vec));
+++ _mm256_store_ps(bPtr, cosine);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = cos(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 for aligned */
++@@ -256,86 +295,105 @@ static inline void
++ #include <smmintrin.h>
++
++ static inline void
++- volk_32f_cos_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
+++volk_32f_cos_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int quarterPoints = num_points / 4;
++- unsigned int i = 0;
++-
++- __m128 aVal, s, r, m4pi, pio4A, pio4B, pio4C, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m128 sine, cosine;
++- __m128i q, ones, twos, fours;
++-
++- m4pi = _mm_set1_ps(1.273239544735162542821171882678754627704620361328125);
++- pio4A = _mm_set1_ps(0.7853981554508209228515625);
++- pio4B = _mm_set1_ps(0.794662735614792836713604629039764404296875e-8);
++- pio4C = _mm_set1_ps(0.306161699786838294306516483068750264552437361480769e-16);
++- ffours = _mm_set1_ps(4.0);
++- ftwos = _mm_set1_ps(2.0);
++- fones = _mm_set1_ps(1.0);
++- fzeroes = _mm_setzero_ps();
++- __m128i zeroes = _mm_set1_epi32(0);
++- ones = _mm_set1_epi32(1);
++- __m128i allones = _mm_set1_epi32(0xffffffff);
++- twos = _mm_set1_epi32(2);
++- fours = _mm_set1_epi32(4);
++-
++- cp1 = _mm_set1_ps(1.0);
++- cp2 = _mm_set1_ps(0.08333333333333333);
++- cp3 = _mm_set1_ps(0.002777777777777778);
++- cp4 = _mm_set1_ps(4.96031746031746e-05);
++- cp5 = _mm_set1_ps(5.511463844797178e-07);
++- union bit128 condition1;
++- union bit128 condition3;
++-
++- for(;number < quarterPoints; number++){
++-
++- aVal = _mm_load_ps(aPtr);
++- // s = fabs(aVal)
++- s = _mm_sub_ps(aVal, _mm_and_ps(_mm_mul_ps(aVal, ftwos), _mm_cmplt_ps(aVal, fzeroes)));
++- // q = (int) (s * (4/pi)), floor(aVal / (pi/4))
++- q = _mm_cvtps_epi32(_mm_floor_ps(_mm_mul_ps(s, m4pi)));
++- // r = q + q&1, q indicates quadrant, r gives
++- r = _mm_cvtepi32_ps(_mm_add_epi32(q, _mm_and_si128(q, ones)));
++-
++- s = _mm_sub_ps(s, _mm_mul_ps(r, pio4A));
++- s = _mm_sub_ps(s, _mm_mul_ps(r, pio4B));
++- s = _mm_sub_ps(s, _mm_mul_ps(r, pio4C));
++-
++- s = _mm_div_ps(s, _mm_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
++-
++- for(i = 0; i < 3; i++)
++- s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
++- s = _mm_div_ps(s, ftwos);
++-
++- sine = _mm_sqrt_ps(_mm_mul_ps(_mm_sub_ps(ftwos, s), s));
++- cosine = _mm_sub_ps(fones, s);
++-
++- // if(((q+1)&2) != 0) { cosine=sine;}
++- condition1.int_vec = _mm_cmpeq_epi32(_mm_and_si128(_mm_add_epi32(q, ones), twos), zeroes);
++- condition1.int_vec = _mm_xor_si128(allones, condition1.int_vec);
++-
++- // if(((q+2)&4) != 0) { cosine = -cosine;}
++- condition3.int_vec = _mm_cmpeq_epi32(_mm_and_si128(_mm_add_epi32(q, twos), fours), zeroes);
++- condition3.int_vec = _mm_xor_si128(allones, condition3.int_vec);
++-
++- cosine = _mm_add_ps(cosine, _mm_and_ps(_mm_sub_ps(sine, cosine), condition1.float_vec));
++- cosine = _mm_sub_ps(cosine, _mm_and_ps(_mm_mul_ps(cosine, _mm_set1_ps(2.0f)), condition3.float_vec));
++- _mm_store_ps(bPtr, cosine);
++- aPtr += 4;
++- bPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *bPtr++ = cosf(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int quarterPoints = num_points / 4;
+++ unsigned int i = 0;
+++
+++ __m128 aVal, s, r, m4pi, pio4A, pio4B, pio4C, cp1, cp2, cp3, cp4, cp5, ffours, ftwos,
+++ fones, fzeroes;
+++ __m128 sine, cosine;
+++ __m128i q, ones, twos, fours;
+++
+++ m4pi = _mm_set1_ps(1.273239544735162542821171882678754627704620361328125);
+++ pio4A = _mm_set1_ps(0.7853981554508209228515625);
+++ pio4B = _mm_set1_ps(0.794662735614792836713604629039764404296875e-8);
+++ pio4C = _mm_set1_ps(0.306161699786838294306516483068750264552437361480769e-16);
+++ ffours = _mm_set1_ps(4.0);
+++ ftwos = _mm_set1_ps(2.0);
+++ fones = _mm_set1_ps(1.0);
+++ fzeroes = _mm_setzero_ps();
+++ __m128i zeroes = _mm_set1_epi32(0);
+++ ones = _mm_set1_epi32(1);
+++ __m128i allones = _mm_set1_epi32(0xffffffff);
+++ twos = _mm_set1_epi32(2);
+++ fours = _mm_set1_epi32(4);
+++
+++ cp1 = _mm_set1_ps(1.0);
+++ cp2 = _mm_set1_ps(0.08333333333333333);
+++ cp3 = _mm_set1_ps(0.002777777777777778);
+++ cp4 = _mm_set1_ps(4.96031746031746e-05);
+++ cp5 = _mm_set1_ps(5.511463844797178e-07);
+++ union bit128 condition1;
+++ union bit128 condition3;
+++
+++ for (; number < quarterPoints; number++) {
+++
+++ aVal = _mm_load_ps(aPtr);
+++ // s = fabs(aVal)
+++ s = _mm_sub_ps(aVal,
+++ _mm_and_ps(_mm_mul_ps(aVal, ftwos), _mm_cmplt_ps(aVal, fzeroes)));
+++ // q = (int) (s * (4/pi)), floor(aVal / (pi/4))
+++ q = _mm_cvtps_epi32(_mm_floor_ps(_mm_mul_ps(s, m4pi)));
+++ // r = q + q&1, q indicates quadrant, r gives
+++ r = _mm_cvtepi32_ps(_mm_add_epi32(q, _mm_and_si128(q, ones)));
+++
+++ s = _mm_sub_ps(s, _mm_mul_ps(r, pio4A));
+++ s = _mm_sub_ps(s, _mm_mul_ps(r, pio4B));
+++ s = _mm_sub_ps(s, _mm_mul_ps(r, pio4C));
+++
+++ s = _mm_div_ps(
+++ s, _mm_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm_mul_ps(
+++ _mm_add_ps(
+++ _mm_mul_ps(
+++ _mm_sub_ps(
+++ _mm_mul_ps(
+++ _mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s),
+++ cp3),
+++ s),
+++ cp2),
+++ s),
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++)
+++ s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
+++ s = _mm_div_ps(s, ftwos);
+++
+++ sine = _mm_sqrt_ps(_mm_mul_ps(_mm_sub_ps(ftwos, s), s));
+++ cosine = _mm_sub_ps(fones, s);
+++
+++ // if(((q+1)&2) != 0) { cosine=sine;}
+++ condition1.int_vec =
+++ _mm_cmpeq_epi32(_mm_and_si128(_mm_add_epi32(q, ones), twos), zeroes);
+++ condition1.int_vec = _mm_xor_si128(allones, condition1.int_vec);
+++
+++ // if(((q+2)&4) != 0) { cosine = -cosine;}
+++ condition3.int_vec =
+++ _mm_cmpeq_epi32(_mm_and_si128(_mm_add_epi32(q, twos), fours), zeroes);
+++ condition3.int_vec = _mm_xor_si128(allones, condition3.int_vec);
+++
+++ cosine = _mm_add_ps(cosine,
+++ _mm_and_ps(_mm_sub_ps(sine, cosine), condition1.float_vec));
+++ cosine = _mm_sub_ps(
+++ cosine,
+++ _mm_and_ps(_mm_mul_ps(cosine, _mm_set1_ps(2.0f)), condition3.float_vec));
+++ _mm_store_ps(bPtr, cosine);
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = cosf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for aligned */
++@@ -343,7 +401,6 @@ static inline void
++ #endif /* INCLUDED_volk_32f_cos_32f_a_H */
++
++
++-
++ #ifndef INCLUDED_volk_32f_cos_32f_u_H
++ #define INCLUDED_volk_32f_cos_32f_u_H
++
++@@ -351,86 +408,102 @@ static inline void
++ #include <immintrin.h>
++
++ static inline void
++- volk_32f_cos_32f_u_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
+++volk_32f_cos_32f_u_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- unsigned int i = 0;
++-
++- __m256 aVal, s, r, m4pi, pio4A, pio4B, pio4C, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m256 sine, cosine;
++- __m256i q, ones, twos, fours;
++-
++- m4pi = _mm256_set1_ps(1.273239544735162542821171882678754627704620361328125);
++- pio4A = _mm256_set1_ps(0.7853981554508209228515625);
++- pio4B = _mm256_set1_ps(0.794662735614792836713604629039764404296875e-8);
++- pio4C = _mm256_set1_ps(0.306161699786838294306516483068750264552437361480769e-16);
++- ffours = _mm256_set1_ps(4.0);
++- ftwos = _mm256_set1_ps(2.0);
++- fones = _mm256_set1_ps(1.0);
++- fzeroes = _mm256_setzero_ps();
++- __m256i zeroes = _mm256_set1_epi32(0);
++- ones = _mm256_set1_epi32(1);
++- __m256i allones = _mm256_set1_epi32(0xffffffff);
++- twos = _mm256_set1_epi32(2);
++- fours = _mm256_set1_epi32(4);
++-
++- cp1 = _mm256_set1_ps(1.0);
++- cp2 = _mm256_set1_ps(0.08333333333333333);
++- cp3 = _mm256_set1_ps(0.002777777777777778);
++- cp4 = _mm256_set1_ps(4.96031746031746e-05);
++- cp5 = _mm256_set1_ps(5.511463844797178e-07);
++- union bit256 condition1;
++- union bit256 condition3;
++-
++- for(;number < eighthPoints; number++){
++-
++- aVal = _mm256_loadu_ps(aPtr);
++- // s = fabs(aVal)
++- s = _mm256_sub_ps(aVal, _mm256_and_ps(_mm256_mul_ps(aVal, ftwos), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
++- // q = (int) (s * (4/pi)), floor(aVal / (pi/4))
++- q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
++- // r = q + q&1, q indicates quadrant, r gives
++- r = _mm256_cvtepi32_ps(_mm256_add_epi32(q, _mm256_and_si256(q, ones)));
++-
++- s = _mm256_fnmadd_ps(r,pio4A,s);
++- s = _mm256_fnmadd_ps(r,pio4B,s);
++- s = _mm256_fnmadd_ps(r,pio4C,s);
++-
++- s = _mm256_div_ps(s, _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm256_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm256_mul_ps(_mm256_fmadd_ps(_mm256_fmsub_ps(_mm256_fmadd_ps(_mm256_fmsub_ps(s, cp5, cp4), s, cp3), s, cp2), s, cp1), s);
++-
++- for(i = 0; i < 3; i++)
++- s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
++- s = _mm256_div_ps(s, ftwos);
++-
++- sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
++- cosine = _mm256_sub_ps(fones, s);
++-
++- // if(((q+1)&2) != 0) { cosine=sine;}
++- condition1.int_vec = _mm256_cmpeq_epi32(_mm256_and_si256(_mm256_add_epi32(q, ones), twos), zeroes);
++- condition1.int_vec = _mm256_xor_si256(allones, condition1.int_vec);
++-
++- // if(((q+2)&4) != 0) { cosine = -cosine;}
++- condition3.int_vec = _mm256_cmpeq_epi32(_mm256_and_si256(_mm256_add_epi32(q, twos), fours), zeroes);
++- condition3.int_vec = _mm256_xor_si256(allones, condition3.int_vec);
++-
++- cosine = _mm256_add_ps(cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1.float_vec));
++- cosine = _mm256_sub_ps(cosine, _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)), condition3.float_vec));
++- _mm256_storeu_ps(bPtr, cosine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = cos(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ unsigned int i = 0;
+++
+++ __m256 aVal, s, r, m4pi, pio4A, pio4B, pio4C, cp1, cp2, cp3, cp4, cp5, ffours, ftwos,
+++ fones, fzeroes;
+++ __m256 sine, cosine;
+++ __m256i q, ones, twos, fours;
+++
+++ m4pi = _mm256_set1_ps(1.273239544735162542821171882678754627704620361328125);
+++ pio4A = _mm256_set1_ps(0.7853981554508209228515625);
+++ pio4B = _mm256_set1_ps(0.794662735614792836713604629039764404296875e-8);
+++ pio4C = _mm256_set1_ps(0.306161699786838294306516483068750264552437361480769e-16);
+++ ffours = _mm256_set1_ps(4.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ fones = _mm256_set1_ps(1.0);
+++ fzeroes = _mm256_setzero_ps();
+++ __m256i zeroes = _mm256_set1_epi32(0);
+++ ones = _mm256_set1_epi32(1);
+++ __m256i allones = _mm256_set1_epi32(0xffffffff);
+++ twos = _mm256_set1_epi32(2);
+++ fours = _mm256_set1_epi32(4);
+++
+++ cp1 = _mm256_set1_ps(1.0);
+++ cp2 = _mm256_set1_ps(0.08333333333333333);
+++ cp3 = _mm256_set1_ps(0.002777777777777778);
+++ cp4 = _mm256_set1_ps(4.96031746031746e-05);
+++ cp5 = _mm256_set1_ps(5.511463844797178e-07);
+++ union bit256 condition1;
+++ union bit256 condition3;
+++
+++ for (; number < eighthPoints; number++) {
+++
+++ aVal = _mm256_loadu_ps(aPtr);
+++ // s = fabs(aVal)
+++ s = _mm256_sub_ps(aVal,
+++ _mm256_and_ps(_mm256_mul_ps(aVal, ftwos),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
+++ // q = (int) (s * (4/pi)), floor(aVal / (pi/4))
+++ q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
+++ // r = q + q&1, q indicates quadrant, r gives
+++ r = _mm256_cvtepi32_ps(_mm256_add_epi32(q, _mm256_and_si256(q, ones)));
+++
+++ s = _mm256_fnmadd_ps(r, pio4A, s);
+++ s = _mm256_fnmadd_ps(r, pio4B, s);
+++ s = _mm256_fnmadd_ps(r, pio4C, s);
+++
+++ s = _mm256_div_ps(
+++ s,
+++ _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm256_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm256_mul_ps(
+++ _mm256_fmadd_ps(
+++ _mm256_fmsub_ps(
+++ _mm256_fmadd_ps(_mm256_fmsub_ps(s, cp5, cp4), s, cp3), s, cp2),
+++ s,
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++)
+++ s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ s = _mm256_div_ps(s, ftwos);
+++
+++ sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
+++ cosine = _mm256_sub_ps(fones, s);
+++
+++ // if(((q+1)&2) != 0) { cosine=sine;}
+++ condition1.int_vec =
+++ _mm256_cmpeq_epi32(_mm256_and_si256(_mm256_add_epi32(q, ones), twos), zeroes);
+++ condition1.int_vec = _mm256_xor_si256(allones, condition1.int_vec);
+++
+++ // if(((q+2)&4) != 0) { cosine = -cosine;}
+++ condition3.int_vec = _mm256_cmpeq_epi32(
+++ _mm256_and_si256(_mm256_add_epi32(q, twos), fours), zeroes);
+++ condition3.int_vec = _mm256_xor_si256(allones, condition3.int_vec);
+++
+++ cosine = _mm256_add_ps(
+++ cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1.float_vec));
+++ cosine = _mm256_sub_ps(cosine,
+++ _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)),
+++ condition3.float_vec));
+++ _mm256_storeu_ps(bPtr, cosine);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = cos(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for unaligned */
++@@ -439,86 +512,109 @@ static inline void
++ #include <immintrin.h>
++
++ static inline void
++- volk_32f_cos_32f_u_avx2(float* bVector, const float* aVector, unsigned int num_points)
+++volk_32f_cos_32f_u_avx2(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- unsigned int i = 0;
++-
++- __m256 aVal, s, r, m4pi, pio4A, pio4B, pio4C, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m256 sine, cosine;
++- __m256i q, ones, twos, fours;
++-
++- m4pi = _mm256_set1_ps(1.273239544735162542821171882678754627704620361328125);
++- pio4A = _mm256_set1_ps(0.7853981554508209228515625);
++- pio4B = _mm256_set1_ps(0.794662735614792836713604629039764404296875e-8);
++- pio4C = _mm256_set1_ps(0.306161699786838294306516483068750264552437361480769e-16);
++- ffours = _mm256_set1_ps(4.0);
++- ftwos = _mm256_set1_ps(2.0);
++- fones = _mm256_set1_ps(1.0);
++- fzeroes = _mm256_setzero_ps();
++- __m256i zeroes = _mm256_set1_epi32(0);
++- ones = _mm256_set1_epi32(1);
++- __m256i allones = _mm256_set1_epi32(0xffffffff);
++- twos = _mm256_set1_epi32(2);
++- fours = _mm256_set1_epi32(4);
++-
++- cp1 = _mm256_set1_ps(1.0);
++- cp2 = _mm256_set1_ps(0.08333333333333333);
++- cp3 = _mm256_set1_ps(0.002777777777777778);
++- cp4 = _mm256_set1_ps(4.96031746031746e-05);
++- cp5 = _mm256_set1_ps(5.511463844797178e-07);
++- union bit256 condition1;
++- union bit256 condition3;
++-
++- for(;number < eighthPoints; number++){
++-
++- aVal = _mm256_loadu_ps(aPtr);
++- // s = fabs(aVal)
++- s = _mm256_sub_ps(aVal, _mm256_and_ps(_mm256_mul_ps(aVal, ftwos), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
++- // q = (int) (s * (4/pi)), floor(aVal / (pi/4))
++- q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
++- // r = q + q&1, q indicates quadrant, r gives
++- r = _mm256_cvtepi32_ps(_mm256_add_epi32(q, _mm256_and_si256(q, ones)));
++-
++- s = _mm256_sub_ps(s, _mm256_mul_ps(r,pio4A));
++- s = _mm256_sub_ps(s, _mm256_mul_ps(r,pio4B));
++- s = _mm256_sub_ps(s, _mm256_mul_ps(r,pio4C));
++-
++- s = _mm256_div_ps(s, _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm256_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm256_mul_ps(_mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(_mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
++-
++- for(i = 0; i < 3; i++)
++- s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
++- s = _mm256_div_ps(s, ftwos);
++-
++- sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
++- cosine = _mm256_sub_ps(fones, s);
++-
++- // if(((q+1)&2) != 0) { cosine=sine;}
++- condition1.int_vec = _mm256_cmpeq_epi32(_mm256_and_si256(_mm256_add_epi32(q, ones), twos), zeroes);
++- condition1.int_vec = _mm256_xor_si256(allones, condition1.int_vec);
++-
++- // if(((q+2)&4) != 0) { cosine = -cosine;}
++- condition3.int_vec = _mm256_cmpeq_epi32(_mm256_and_si256(_mm256_add_epi32(q, twos), fours), zeroes);
++- condition3.int_vec = _mm256_xor_si256(allones, condition3.int_vec);
++-
++- cosine = _mm256_add_ps(cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1.float_vec));
++- cosine = _mm256_sub_ps(cosine, _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)), condition3.float_vec));
++- _mm256_storeu_ps(bPtr, cosine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = cos(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ unsigned int i = 0;
+++
+++ __m256 aVal, s, r, m4pi, pio4A, pio4B, pio4C, cp1, cp2, cp3, cp4, cp5, ffours, ftwos,
+++ fones, fzeroes;
+++ __m256 sine, cosine;
+++ __m256i q, ones, twos, fours;
+++
+++ m4pi = _mm256_set1_ps(1.273239544735162542821171882678754627704620361328125);
+++ pio4A = _mm256_set1_ps(0.7853981554508209228515625);
+++ pio4B = _mm256_set1_ps(0.794662735614792836713604629039764404296875e-8);
+++ pio4C = _mm256_set1_ps(0.306161699786838294306516483068750264552437361480769e-16);
+++ ffours = _mm256_set1_ps(4.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ fones = _mm256_set1_ps(1.0);
+++ fzeroes = _mm256_setzero_ps();
+++ __m256i zeroes = _mm256_set1_epi32(0);
+++ ones = _mm256_set1_epi32(1);
+++ __m256i allones = _mm256_set1_epi32(0xffffffff);
+++ twos = _mm256_set1_epi32(2);
+++ fours = _mm256_set1_epi32(4);
+++
+++ cp1 = _mm256_set1_ps(1.0);
+++ cp2 = _mm256_set1_ps(0.08333333333333333);
+++ cp3 = _mm256_set1_ps(0.002777777777777778);
+++ cp4 = _mm256_set1_ps(4.96031746031746e-05);
+++ cp5 = _mm256_set1_ps(5.511463844797178e-07);
+++ union bit256 condition1;
+++ union bit256 condition3;
+++
+++ for (; number < eighthPoints; number++) {
+++
+++ aVal = _mm256_loadu_ps(aPtr);
+++ // s = fabs(aVal)
+++ s = _mm256_sub_ps(aVal,
+++ _mm256_and_ps(_mm256_mul_ps(aVal, ftwos),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
+++ // q = (int) (s * (4/pi)), floor(aVal / (pi/4))
+++ q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
+++ // r = q + q&1, q indicates quadrant, r gives
+++ r = _mm256_cvtepi32_ps(_mm256_add_epi32(q, _mm256_and_si256(q, ones)));
+++
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(r, pio4A));
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(r, pio4B));
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(r, pio4C));
+++
+++ s = _mm256_div_ps(
+++ s,
+++ _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm256_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm256_mul_ps(
+++ _mm256_add_ps(
+++ _mm256_mul_ps(
+++ _mm256_sub_ps(
+++ _mm256_mul_ps(
+++ _mm256_add_ps(
+++ _mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(s, cp5), cp4),
+++ s),
+++ cp3),
+++ s),
+++ cp2),
+++ s),
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++)
+++ s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ s = _mm256_div_ps(s, ftwos);
+++
+++ sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
+++ cosine = _mm256_sub_ps(fones, s);
+++
+++ // if(((q+1)&2) != 0) { cosine=sine;}
+++ condition1.int_vec =
+++ _mm256_cmpeq_epi32(_mm256_and_si256(_mm256_add_epi32(q, ones), twos), zeroes);
+++ condition1.int_vec = _mm256_xor_si256(allones, condition1.int_vec);
+++
+++ // if(((q+2)&4) != 0) { cosine = -cosine;}
+++ condition3.int_vec = _mm256_cmpeq_epi32(
+++ _mm256_and_si256(_mm256_add_epi32(q, twos), fours), zeroes);
+++ condition3.int_vec = _mm256_xor_si256(allones, condition3.int_vec);
+++
+++ cosine = _mm256_add_ps(
+++ cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1.float_vec));
+++ cosine = _mm256_sub_ps(cosine,
+++ _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)),
+++ condition3.float_vec));
+++ _mm256_storeu_ps(bPtr, cosine);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = cos(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 for unaligned */
++@@ -529,71 +625,88 @@ static inline void
++ static inline void
++ volk_32f_cos_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int quarterPoints = num_points / 4;
++- unsigned int i = 0;
++-
++- __m128 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m128 sine, cosine, condition1, condition3;
++- __m128i q, r, ones, twos, fours;
++-
++- m4pi = _mm_set1_ps(1.273239545);
++- pio4A = _mm_set1_ps(0.78515625);
++- pio4B = _mm_set1_ps(0.241876e-3);
++- ffours = _mm_set1_ps(4.0);
++- ftwos = _mm_set1_ps(2.0);
++- fones = _mm_set1_ps(1.0);
++- fzeroes = _mm_setzero_ps();
++- ones = _mm_set1_epi32(1);
++- twos = _mm_set1_epi32(2);
++- fours = _mm_set1_epi32(4);
++-
++- cp1 = _mm_set1_ps(1.0);
++- cp2 = _mm_set1_ps(0.83333333e-1);
++- cp3 = _mm_set1_ps(0.2777778e-2);
++- cp4 = _mm_set1_ps(0.49603e-4);
++- cp5 = _mm_set1_ps(0.551e-6);
++-
++- for(;number < quarterPoints; number++){
++- aVal = _mm_loadu_ps(aPtr);
++- s = _mm_sub_ps(aVal, _mm_and_ps(_mm_mul_ps(aVal, ftwos), _mm_cmplt_ps(aVal, fzeroes)));
++- q = _mm_cvtps_epi32(_mm_floor_ps(_mm_mul_ps(s, m4pi)));
++- r = _mm_add_epi32(q, _mm_and_si128(q, ones));
++-
++- s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4A));
++- s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4B));
++-
++- s = _mm_div_ps(s, _mm_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
++-
++- for(i = 0; i < 3; i++){
++- s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
++- }
++- s = _mm_div_ps(s, ftwos);
++-
++- sine = _mm_sqrt_ps(_mm_mul_ps(_mm_sub_ps(ftwos, s), s));
++- cosine = _mm_sub_ps(fones, s);
++-
++- condition1 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, ones), twos)), fzeroes);
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
++
++- condition3 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, twos), fours)), fzeroes);
++-
++- cosine = _mm_add_ps(cosine, _mm_and_ps(_mm_sub_ps(sine, cosine), condition1));
++- cosine = _mm_sub_ps(cosine, _mm_and_ps(_mm_mul_ps(cosine, _mm_set1_ps(2.0f)), condition3));
++- _mm_storeu_ps(bPtr, cosine);
++- aPtr += 4;
++- bPtr += 4;
++- }
+++ unsigned int number = 0;
+++ unsigned int quarterPoints = num_points / 4;
+++ unsigned int i = 0;
+++
+++ __m128 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones,
+++ fzeroes;
+++ __m128 sine, cosine, condition1, condition3;
+++ __m128i q, r, ones, twos, fours;
+++
+++ m4pi = _mm_set1_ps(1.273239545);
+++ pio4A = _mm_set1_ps(0.78515625);
+++ pio4B = _mm_set1_ps(0.241876e-3);
+++ ffours = _mm_set1_ps(4.0);
+++ ftwos = _mm_set1_ps(2.0);
+++ fones = _mm_set1_ps(1.0);
+++ fzeroes = _mm_setzero_ps();
+++ ones = _mm_set1_epi32(1);
+++ twos = _mm_set1_epi32(2);
+++ fours = _mm_set1_epi32(4);
+++
+++ cp1 = _mm_set1_ps(1.0);
+++ cp2 = _mm_set1_ps(0.83333333e-1);
+++ cp3 = _mm_set1_ps(0.2777778e-2);
+++ cp4 = _mm_set1_ps(0.49603e-4);
+++ cp5 = _mm_set1_ps(0.551e-6);
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_loadu_ps(aPtr);
+++ s = _mm_sub_ps(aVal,
+++ _mm_and_ps(_mm_mul_ps(aVal, ftwos), _mm_cmplt_ps(aVal, fzeroes)));
+++ q = _mm_cvtps_epi32(_mm_floor_ps(_mm_mul_ps(s, m4pi)));
+++ r = _mm_add_epi32(q, _mm_and_si128(q, ones));
+++
+++ s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4A));
+++ s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4B));
+++
+++ s = _mm_div_ps(
+++ s, _mm_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm_mul_ps(
+++ _mm_add_ps(
+++ _mm_mul_ps(
+++ _mm_sub_ps(
+++ _mm_mul_ps(
+++ _mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s),
+++ cp3),
+++ s),
+++ cp2),
+++ s),
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++) {
+++ s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
+++ }
+++ s = _mm_div_ps(s, ftwos);
+++
+++ sine = _mm_sqrt_ps(_mm_mul_ps(_mm_sub_ps(ftwos, s), s));
+++ cosine = _mm_sub_ps(fones, s);
+++
+++ condition1 = _mm_cmpneq_ps(
+++ _mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, ones), twos)), fzeroes);
+++
+++ condition3 = _mm_cmpneq_ps(
+++ _mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, twos), fours)), fzeroes);
+++
+++ cosine = _mm_add_ps(cosine, _mm_and_ps(_mm_sub_ps(sine, cosine), condition1));
+++ cosine = _mm_sub_ps(
+++ cosine, _mm_and_ps(_mm_mul_ps(cosine, _mm_set1_ps(2.0f)), condition3));
+++ _mm_storeu_ps(bPtr, cosine);
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *bPtr++ = cosf(*aPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = cosf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for unaligned */
++@@ -606,52 +719,55 @@ volk_32f_cos_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int num
++ * Shibata, Naoki, "Efficient evaluation methods of elementary functions
++ * suitable for SIMD computation," in Springer-Verlag 2010
++ */
++-static inline void
++-volk_32f_cos_32f_generic_fast(float* bVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_cos_32f_generic_fast(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- float m4pi = 1.273239544735162542821171882678754627704620361328125;
++- float pio4A = 0.7853981554508209228515625;
++- float pio4B = 0.794662735614792836713604629039764404296875e-8;
++- float pio4C = 0.306161699786838294306516483068750264552437361480769e-16;
++- int N = 3; // order of argument reduction
++-
++- unsigned int number;
++- for(number = 0; number < num_points; number++){
++- float s = fabs(*aPtr);
++- int q = (int)(s * m4pi);
++- int r = q + (q&1);
++- s -= r * pio4A;
++- s -= r * pio4B;
++- s -= r * pio4C;
++-
++- s = s * 0.125; // 2^-N (<--3)
++- s = s*s;
++- s = ((((s/1814400. - 1.0/20160.0)*s + 1.0/360.0)*s - 1.0/12.0)*s + 1.0)*s;
++-
++- int i;
++- for(i=0; i < N; ++i) {
++- s = (4.0-s)*s;
++- }
++- s = s/2.0;
++-
++- float sine = sqrt((2.0-s)*s);
++- float cosine = 1-s;
++-
++- if (((q+1) & 2) != 0) {
++- s = cosine;
++- cosine = sine;
++- sine = s;
++- }
++- if (((q+2) & 4) != 0) {
++- cosine = -cosine;
++- }
++- *bPtr = cosine;
++- bPtr++;
++- aPtr++;
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ float m4pi = 1.273239544735162542821171882678754627704620361328125;
+++ float pio4A = 0.7853981554508209228515625;
+++ float pio4B = 0.794662735614792836713604629039764404296875e-8;
+++ float pio4C = 0.306161699786838294306516483068750264552437361480769e-16;
+++ int N = 3; // order of argument reduction
+++
+++ unsigned int number;
+++ for (number = 0; number < num_points; number++) {
+++ float s = fabs(*aPtr);
+++ int q = (int)(s * m4pi);
+++ int r = q + (q & 1);
+++ s -= r * pio4A;
+++ s -= r * pio4B;
+++ s -= r * pio4C;
+++
+++ s = s * 0.125; // 2^-N (<--3)
+++ s = s * s;
+++ s = ((((s / 1814400. - 1.0 / 20160.0) * s + 1.0 / 360.0) * s - 1.0 / 12.0) * s +
+++ 1.0) *
+++ s;
+++
+++ int i;
+++ for (i = 0; i < N; ++i) {
+++ s = (4.0 - s) * s;
+++ }
+++ s = s / 2.0;
+++
+++ float sine = sqrt((2.0 - s) * s);
+++ float cosine = 1 - s;
+++
+++ if (((q + 1) & 2) != 0) {
+++ s = cosine;
+++ cosine = sine;
+++ sine = s;
+++ }
+++ if (((q + 2) & 4) != 0) {
+++ cosine = -cosine;
+++ }
+++ *bPtr = cosine;
+++ bPtr++;
+++ aPtr++;
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -662,13 +778,13 @@ volk_32f_cos_32f_generic_fast(float* bVector, const float* aVector, unsigned int
++ static inline void
++ volk_32f_cos_32f_generic(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(; number < num_points; number++){
++- *bPtr++ = cosf(*aPtr++);
++- }
+++ for (; number < num_points; number++) {
+++ *bPtr++ = cosf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -679,30 +795,29 @@ volk_32f_cos_32f_generic(float* bVector, const float* aVector, unsigned int num_
++ #include <volk/volk_neon_intrinsics.h>
++
++ static inline void
++-volk_32f_cos_32f_neon(float* bVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_cos_32f_neon(float* bVector, const float* aVector, unsigned int num_points)
++ {
++ unsigned int number = 0;
++ unsigned int quarter_points = num_points / 4;
++ float* bVectorPtr = bVector;
++ const float* aVectorPtr = aVector;
++-
+++
++ float32x4_t b_vec;
++ float32x4_t a_vec;
++-
++- for(number = 0; number < quarter_points; number++) {
+++
+++ for (number = 0; number < quarter_points; number++) {
++ a_vec = vld1q_f32(aVectorPtr);
++ // Prefetch next one, speeds things up
++- __VOLK_PREFETCH(aVectorPtr+4);
+++ __VOLK_PREFETCH(aVectorPtr + 4);
++ b_vec = _vcosq_f32(a_vec);
++ vst1q_f32(bVectorPtr, b_vec);
++ // move pointers ahead
++- bVectorPtr+=4;
++- aVectorPtr+=4;
+++ bVectorPtr += 4;
+++ aVectorPtr += 4;
++ }
++-
+++
++ // Deal with the rest
++- for(number = quarter_points * 4; number < num_points; number++) {
+++ for (number = quarter_points * 4; number < num_points; number++) {
++ *bVectorPtr++ = cosf(*aVectorPtr++);
++ }
++ }
++diff --git a/kernels/volk/volk_32f_expfast_32f.h b/kernels/volk/volk_32f_expfast_32f.h
++index ecb4914..45de3f9 100644
++--- a/kernels/volk/volk_32f_expfast_32f.h
+++++ b/kernels/volk/volk_32f_expfast_32f.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_expfast_32f(float* bVector, const float* aVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_expfast_32f(float* bVector, const float* aVector, unsigned int
+++ * num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: Input vector of floats.
++@@ -62,9 +62,9 @@
++ * \endcode
++ */
++
++-#include <stdio.h>
++-#include <math.h>
++ #include <inttypes.h>
+++#include <math.h>
+++#include <stdio.h>
++
++ #define Mln2 0.6931471805f
++ #define A 8388608.0f
++@@ -79,34 +79,35 @@
++
++ #include <immintrin.h>
++
++-static inline void
++- volk_32f_expfast_32f_a_avx_fma(float* bVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_expfast_32f_a_avx_fma(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- __m256 aVal, bVal, a, b;
++- __m256i exp;
++- a = _mm256_set1_ps(A/Mln2);
++- b = _mm256_set1_ps(B-C);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- exp = _mm256_cvtps_epi32(_mm256_fmadd_ps(a,aVal, b));
++- bVal = _mm256_castsi256_ps(exp);
++-
++- _mm256_store_ps(bPtr, bVal);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = expf(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ __m256 aVal, bVal, a, b;
+++ __m256i exp;
+++ a = _mm256_set1_ps(A / Mln2);
+++ b = _mm256_set1_ps(B - C);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ exp = _mm256_cvtps_epi32(_mm256_fmadd_ps(a, aVal, b));
+++ bVal = _mm256_castsi256_ps(exp);
+++
+++ _mm256_store_ps(bPtr, bVal);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = expf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX && LV_HAVE_FMA for aligned */
++@@ -116,33 +117,33 @@ static inline void
++ #include <immintrin.h>
++
++ static inline void
++- volk_32f_expfast_32f_a_avx(float* bVector, const float* aVector, unsigned int num_points)
+++volk_32f_expfast_32f_a_avx(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- __m256 aVal, bVal, a, b;
++- __m256i exp;
++- a = _mm256_set1_ps(A/Mln2);
++- b = _mm256_set1_ps(B-C);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- exp = _mm256_cvtps_epi32(_mm256_add_ps(_mm256_mul_ps(a,aVal), b));
++- bVal = _mm256_castsi256_ps(exp);
++-
++- _mm256_store_ps(bPtr, bVal);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = expf(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ __m256 aVal, bVal, a, b;
+++ __m256i exp;
+++ a = _mm256_set1_ps(A / Mln2);
+++ b = _mm256_set1_ps(B - C);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ exp = _mm256_cvtps_epi32(_mm256_add_ps(_mm256_mul_ps(a, aVal), b));
+++ bVal = _mm256_castsi256_ps(exp);
+++
+++ _mm256_store_ps(bPtr, bVal);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = expf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX for aligned */
++@@ -150,34 +151,35 @@ static inline void
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void
++-volk_32f_expfast_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_expfast_32f_a_sse4_1(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- __m128 aVal, bVal, a, b;
++- __m128i exp;
++- a = _mm_set1_ps(A/Mln2);
++- b = _mm_set1_ps(B-C);
++-
++- for(;number < quarterPoints; number++){
++- aVal = _mm_load_ps(aPtr);
++- exp = _mm_cvtps_epi32(_mm_add_ps(_mm_mul_ps(a,aVal), b));
++- bVal = _mm_castsi128_ps(exp);
++-
++- _mm_store_ps(bPtr, bVal);
++- aPtr += 4;
++- bPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *bPtr++ = expf(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ __m128 aVal, bVal, a, b;
+++ __m128i exp;
+++ a = _mm_set1_ps(A / Mln2);
+++ b = _mm_set1_ps(B - C);
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
+++ exp = _mm_cvtps_epi32(_mm_add_ps(_mm_mul_ps(a, aVal), b));
+++ bVal = _mm_castsi128_ps(exp);
+++
+++ _mm_store_ps(bPtr, bVal);
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = expf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for aligned */
++@@ -190,34 +192,35 @@ volk_32f_expfast_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int
++ #if LV_HAVE_AVX && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_expfast_32f_u_avx_fma(float* bVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_expfast_32f_u_avx_fma(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- __m256 aVal, bVal, a, b;
++- __m256i exp;
++- a = _mm256_set1_ps(A/Mln2);
++- b = _mm256_set1_ps(B-C);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- exp = _mm256_cvtps_epi32(_mm256_fmadd_ps(a,aVal, b));
++- bVal = _mm256_castsi256_ps(exp);
++-
++- _mm256_storeu_ps(bPtr, bVal);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = expf(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ __m256 aVal, bVal, a, b;
+++ __m256i exp;
+++ a = _mm256_set1_ps(A / Mln2);
+++ b = _mm256_set1_ps(B - C);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ exp = _mm256_cvtps_epi32(_mm256_fmadd_ps(a, aVal, b));
+++ bVal = _mm256_castsi256_ps(exp);
+++
+++ _mm256_storeu_ps(bPtr, bVal);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = expf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX && LV_HAVE_FMA for unaligned */
++@@ -228,31 +231,31 @@ volk_32f_expfast_32f_u_avx_fma(float* bVector, const float* aVector, unsigned in
++ static inline void
++ volk_32f_expfast_32f_u_avx(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- __m256 aVal, bVal, a, b;
++- __m256i exp;
++- a = _mm256_set1_ps(A/Mln2);
++- b = _mm256_set1_ps(B-C);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- exp = _mm256_cvtps_epi32(_mm256_add_ps(_mm256_mul_ps(a,aVal), b));
++- bVal = _mm256_castsi256_ps(exp);
++-
++- _mm256_storeu_ps(bPtr, bVal);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = expf(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ __m256 aVal, bVal, a, b;
+++ __m256i exp;
+++ a = _mm256_set1_ps(A / Mln2);
+++ b = _mm256_set1_ps(B - C);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ exp = _mm256_cvtps_epi32(_mm256_add_ps(_mm256_mul_ps(a, aVal), b));
+++ bVal = _mm256_castsi256_ps(exp);
+++
+++ _mm256_storeu_ps(bPtr, bVal);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = expf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX for unaligned */
++@@ -261,34 +264,35 @@ volk_32f_expfast_32f_u_avx(float* bVector, const float* aVector, unsigned int nu
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void
++-volk_32f_expfast_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_expfast_32f_u_sse4_1(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- __m128 aVal, bVal, a, b;
++- __m128i exp;
++- a = _mm_set1_ps(A/Mln2);
++- b = _mm_set1_ps(B-C);
++-
++- for(;number < quarterPoints; number++){
++- aVal = _mm_loadu_ps(aPtr);
++- exp = _mm_cvtps_epi32(_mm_add_ps(_mm_mul_ps(a,aVal), b));
++- bVal = _mm_castsi128_ps(exp);
++-
++- _mm_storeu_ps(bPtr, bVal);
++- aPtr += 4;
++- bPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *bPtr++ = expf(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ __m128 aVal, bVal, a, b;
+++ __m128i exp;
+++ a = _mm_set1_ps(A / Mln2);
+++ b = _mm_set1_ps(B - C);
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_loadu_ps(aPtr);
+++ exp = _mm_cvtps_epi32(_mm_add_ps(_mm_mul_ps(a, aVal), b));
+++ bVal = _mm_castsi128_ps(exp);
+++
+++ _mm_storeu_ps(bPtr, bVal);
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = expf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for unaligned */
++@@ -296,16 +300,17 @@ volk_32f_expfast_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_expfast_32f_generic(float* bVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_expfast_32f_generic(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *bPtr++ = expf(*aPtr++);
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *bPtr++ = expf(*aPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32f_index_max_16u.h b/kernels/volk/volk_32f_index_max_16u.h
++index 7ca6928..3ee10f4 100644
++--- a/kernels/volk/volk_32f_index_max_16u.h
+++++ b/kernels/volk/volk_32f_index_max_16u.h
++@@ -71,72 +71,71 @@
++ #ifndef INCLUDED_volk_32f_index_max_16u_a_H
++ #define INCLUDED_volk_32f_index_max_16u_a_H
++
++-#include <volk/volk_common.h>
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <limits.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++ static inline void
++-volk_32f_index_max_16u_a_avx(uint16_t* target, const float* src0,
++- uint32_t num_points)
+++volk_32f_index_max_16u_a_avx(uint16_t* target, const float* src0, uint32_t num_points)
++ {
++- num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
++-
++- uint32_t number = 0;
++- const uint32_t eighthPoints = num_points / 8;
+++ num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
++
++- float* inputPtr = (float*)src0;
+++ uint32_t number = 0;
+++ const uint32_t eighthPoints = num_points / 8;
++
++- __m256 indexIncrementValues = _mm256_set1_ps(8);
++- __m256 currentIndexes = _mm256_set_ps(-1,-2,-3,-4,-5,-6,-7,-8);
+++ float* inputPtr = (float*)src0;
++
++- float max = src0[0];
++- float index = 0;
++- __m256 maxValues = _mm256_set1_ps(max);
++- __m256 maxValuesIndex = _mm256_setzero_ps();
++- __m256 compareResults;
++- __m256 currentValues;
+++ __m256 indexIncrementValues = _mm256_set1_ps(8);
+++ __m256 currentIndexes = _mm256_set_ps(-1, -2, -3, -4, -5, -6, -7, -8);
++
++- __VOLK_ATTR_ALIGNED(32) float maxValuesBuffer[8];
++- __VOLK_ATTR_ALIGNED(32) float maxIndexesBuffer[8];
+++ float max = src0[0];
+++ float index = 0;
+++ __m256 maxValues = _mm256_set1_ps(max);
+++ __m256 maxValuesIndex = _mm256_setzero_ps();
+++ __m256 compareResults;
+++ __m256 currentValues;
++
++- for(;number < eighthPoints; number++){
+++ __VOLK_ATTR_ALIGNED(32) float maxValuesBuffer[8];
+++ __VOLK_ATTR_ALIGNED(32) float maxIndexesBuffer[8];
++
++- currentValues = _mm256_load_ps(inputPtr); inputPtr += 8;
++- currentIndexes = _mm256_add_ps(currentIndexes, indexIncrementValues);
+++ for (; number < eighthPoints; number++) {
++
++- compareResults = _mm256_cmp_ps(currentValues, maxValues, _CMP_GT_OS);
+++ currentValues = _mm256_load_ps(inputPtr);
+++ inputPtr += 8;
+++ currentIndexes = _mm256_add_ps(currentIndexes, indexIncrementValues);
++
++- maxValuesIndex = _mm256_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
++- maxValues = _mm256_blendv_ps(maxValues, currentValues, compareResults);
++- }
+++ compareResults = _mm256_cmp_ps(currentValues, maxValues, _CMP_GT_OS);
++
++- // Calculate the largest value from the remaining 4 points
++- _mm256_store_ps(maxValuesBuffer, maxValues);
++- _mm256_store_ps(maxIndexesBuffer, maxValuesIndex);
+++ maxValuesIndex = _mm256_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
+++ maxValues = _mm256_blendv_ps(maxValues, currentValues, compareResults);
+++ }
++
++- for(number = 0; number < 8; number++){
++- if(maxValuesBuffer[number] > max){
++- index = maxIndexesBuffer[number];
++- max = maxValuesBuffer[number];
++- } else if(maxValuesBuffer[number] == max){
++- if (index > maxIndexesBuffer[number])
++- index = maxIndexesBuffer[number];
+++ // Calculate the largest value from the remaining 4 points
+++ _mm256_store_ps(maxValuesBuffer, maxValues);
+++ _mm256_store_ps(maxIndexesBuffer, maxValuesIndex);
+++
+++ for (number = 0; number < 8; number++) {
+++ if (maxValuesBuffer[number] > max) {
+++ index = maxIndexesBuffer[number];
+++ max = maxValuesBuffer[number];
+++ } else if (maxValuesBuffer[number] == max) {
+++ if (index > maxIndexesBuffer[number])
+++ index = maxIndexesBuffer[number];
+++ }
++ }
++- }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- if(src0[number] > max){
++- index = number;
++- max = src0[number];
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ if (src0[number] > max) {
+++ index = number;
+++ max = src0[number];
+++ }
++ }
++- }
++- target[0] = (uint16_t)index;
+++ target[0] = (uint16_t)index;
++ }
++
++ #endif /*LV_HAVE_AVX*/
++@@ -145,62 +144,62 @@ volk_32f_index_max_16u_a_avx(uint16_t* target, const float* src0,
++ #include <smmintrin.h>
++
++ static inline void
++-volk_32f_index_max_16u_a_sse4_1(uint16_t* target, const float* src0,
++- uint32_t num_points)
+++volk_32f_index_max_16u_a_sse4_1(uint16_t* target, const float* src0, uint32_t num_points)
++ {
++- num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
++-
++- uint32_t number = 0;
++- const uint32_t quarterPoints = num_points / 4;
+++ num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
++
++- float* inputPtr = (float*)src0;
+++ uint32_t number = 0;
+++ const uint32_t quarterPoints = num_points / 4;
++
++- __m128 indexIncrementValues = _mm_set1_ps(4);
++- __m128 currentIndexes = _mm_set_ps(-1,-2,-3,-4);
+++ float* inputPtr = (float*)src0;
++
++- float max = src0[0];
++- float index = 0;
++- __m128 maxValues = _mm_set1_ps(max);
++- __m128 maxValuesIndex = _mm_setzero_ps();
++- __m128 compareResults;
++- __m128 currentValues;
+++ __m128 indexIncrementValues = _mm_set1_ps(4);
+++ __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
++
++- __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
++- __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
+++ float max = src0[0];
+++ float index = 0;
+++ __m128 maxValues = _mm_set1_ps(max);
+++ __m128 maxValuesIndex = _mm_setzero_ps();
+++ __m128 compareResults;
+++ __m128 currentValues;
++
++- for(;number < quarterPoints; number++){
+++ __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
++
++- currentValues = _mm_load_ps(inputPtr); inputPtr += 4;
++- currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
+++ for (; number < quarterPoints; number++) {
++
++- compareResults = _mm_cmpgt_ps(currentValues, maxValues);
+++ currentValues = _mm_load_ps(inputPtr);
+++ inputPtr += 4;
+++ currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
++
++- maxValuesIndex = _mm_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
++- maxValues = _mm_blendv_ps(maxValues, currentValues, compareResults);
++- }
+++ compareResults = _mm_cmpgt_ps(currentValues, maxValues);
++
++- // Calculate the largest value from the remaining 4 points
++- _mm_store_ps(maxValuesBuffer, maxValues);
++- _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
+++ maxValuesIndex = _mm_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
+++ maxValues = _mm_blendv_ps(maxValues, currentValues, compareResults);
+++ }
++
++- for(number = 0; number < 4; number++){
++- if(maxValuesBuffer[number] > max){
++- index = maxIndexesBuffer[number];
++- max = maxValuesBuffer[number];
++- } else if(maxValuesBuffer[number] == max){
++- if (index > maxIndexesBuffer[number])
++- index = maxIndexesBuffer[number];
+++ // Calculate the largest value from the remaining 4 points
+++ _mm_store_ps(maxValuesBuffer, maxValues);
+++ _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
+++
+++ for (number = 0; number < 4; number++) {
+++ if (maxValuesBuffer[number] > max) {
+++ index = maxIndexesBuffer[number];
+++ max = maxValuesBuffer[number];
+++ } else if (maxValuesBuffer[number] == max) {
+++ if (index > maxIndexesBuffer[number])
+++ index = maxIndexesBuffer[number];
+++ }
++ }
++- }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- if(src0[number] > max){
++- index = number;
++- max = src0[number];
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ if (src0[number] > max) {
+++ index = number;
+++ max = src0[number];
+++ }
++ }
++- }
++- target[0] = (uint16_t)index;
+++ target[0] = (uint16_t)index;
++ }
++
++ #endif /*LV_HAVE_SSE4_1*/
++@@ -211,64 +210,64 @@ volk_32f_index_max_16u_a_sse4_1(uint16_t* target, const float* src0,
++ #include <xmmintrin.h>
++
++ static inline void
++-volk_32f_index_max_16u_a_sse(uint16_t* target, const float* src0,
++- uint32_t num_points)
+++volk_32f_index_max_16u_a_sse(uint16_t* target, const float* src0, uint32_t num_points)
++ {
++- num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
++-
++- uint32_t number = 0;
++- const uint32_t quarterPoints = num_points / 4;
+++ num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
++
++- float* inputPtr = (float*)src0;
+++ uint32_t number = 0;
+++ const uint32_t quarterPoints = num_points / 4;
++
++- __m128 indexIncrementValues = _mm_set1_ps(4);
++- __m128 currentIndexes = _mm_set_ps(-1,-2,-3,-4);
+++ float* inputPtr = (float*)src0;
++
++- float max = src0[0];
++- float index = 0;
++- __m128 maxValues = _mm_set1_ps(max);
++- __m128 maxValuesIndex = _mm_setzero_ps();
++- __m128 compareResults;
++- __m128 currentValues;
+++ __m128 indexIncrementValues = _mm_set1_ps(4);
+++ __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
++
++- __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
++- __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
+++ float max = src0[0];
+++ float index = 0;
+++ __m128 maxValues = _mm_set1_ps(max);
+++ __m128 maxValuesIndex = _mm_setzero_ps();
+++ __m128 compareResults;
+++ __m128 currentValues;
++
++- for(;number < quarterPoints; number++){
+++ __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
++
++- currentValues = _mm_load_ps(inputPtr); inputPtr += 4;
++- currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
+++ for (; number < quarterPoints; number++) {
++
++- compareResults = _mm_cmpgt_ps(currentValues, maxValues);
+++ currentValues = _mm_load_ps(inputPtr);
+++ inputPtr += 4;
+++ currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
++
++- maxValuesIndex = _mm_or_ps(_mm_and_ps(compareResults, currentIndexes),
++- _mm_andnot_ps(compareResults, maxValuesIndex));
++- maxValues = _mm_or_ps(_mm_and_ps(compareResults, currentValues),
++- _mm_andnot_ps(compareResults, maxValues));
++- }
+++ compareResults = _mm_cmpgt_ps(currentValues, maxValues);
++
++- // Calculate the largest value from the remaining 4 points
++- _mm_store_ps(maxValuesBuffer, maxValues);
++- _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
+++ maxValuesIndex = _mm_or_ps(_mm_and_ps(compareResults, currentIndexes),
+++ _mm_andnot_ps(compareResults, maxValuesIndex));
+++ maxValues = _mm_or_ps(_mm_and_ps(compareResults, currentValues),
+++ _mm_andnot_ps(compareResults, maxValues));
+++ }
++
++- for(number = 0; number < 4; number++){
++- if(maxValuesBuffer[number] > max){
++- index = maxIndexesBuffer[number];
++- max = maxValuesBuffer[number];
++- } else if(maxValuesBuffer[number] == max){
++- if (index > maxIndexesBuffer[number])
++- index = maxIndexesBuffer[number];
+++ // Calculate the largest value from the remaining 4 points
+++ _mm_store_ps(maxValuesBuffer, maxValues);
+++ _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
+++
+++ for (number = 0; number < 4; number++) {
+++ if (maxValuesBuffer[number] > max) {
+++ index = maxIndexesBuffer[number];
+++ max = maxValuesBuffer[number];
+++ } else if (maxValuesBuffer[number] == max) {
+++ if (index > maxIndexesBuffer[number])
+++ index = maxIndexesBuffer[number];
+++ }
++ }
++- }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- if(src0[number] > max){
++- index = number;
++- max = src0[number];
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ if (src0[number] > max) {
+++ index = number;
+++ max = src0[number];
+++ }
++ }
++- }
++- target[0] = (uint16_t)index;
+++ target[0] = (uint16_t)index;
++ }
++
++ #endif /*LV_HAVE_SSE*/
++@@ -277,23 +276,22 @@ volk_32f_index_max_16u_a_sse(uint16_t* target, const float* src0,
++ #ifdef LV_HAVE_GENERIC
++
++ static inline void
++-volk_32f_index_max_16u_generic(uint16_t* target, const float* src0,
++- uint32_t num_points)
+++volk_32f_index_max_16u_generic(uint16_t* target, const float* src0, uint32_t num_points)
++ {
++- num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
+++ num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
++
++- float max = src0[0];
++- uint16_t index = 0;
+++ float max = src0[0];
+++ uint16_t index = 0;
++
++- uint32_t i = 1;
+++ uint32_t i = 1;
++
++- for(; i < num_points; ++i) {
++- if(src0[i] > max) {
++- index = i;
++- max = src0[i];
+++ for (; i < num_points; ++i) {
+++ if (src0[i] > max) {
+++ index = i;
+++ max = src0[i];
+++ }
++ }
++- }
++- target[0] = index;
+++ target[0] = index;
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -302,76 +300,74 @@ volk_32f_index_max_16u_generic(uint16_t* target, const float* src0,
++ #endif /*INCLUDED_volk_32f_index_max_16u_a_H*/
++
++
++-
++ #ifndef INCLUDED_volk_32f_index_max_16u_u_H
++ #define INCLUDED_volk_32f_index_max_16u_u_H
++
++-#include <volk/volk_common.h>
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <limits.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++ static inline void
++-volk_32f_index_max_16u_u_avx(uint16_t* target, const float* src0,
++- uint32_t num_points)
+++volk_32f_index_max_16u_u_avx(uint16_t* target, const float* src0, uint32_t num_points)
++ {
++- num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
++-
++- uint32_t number = 0;
++- const uint32_t eighthPoints = num_points / 8;
+++ num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
++
++- float* inputPtr = (float*)src0;
+++ uint32_t number = 0;
+++ const uint32_t eighthPoints = num_points / 8;
++
++- __m256 indexIncrementValues = _mm256_set1_ps(8);
++- __m256 currentIndexes = _mm256_set_ps(-1,-2,-3,-4,-5,-6,-7,-8);
+++ float* inputPtr = (float*)src0;
++
++- float max = src0[0];
++- float index = 0;
++- __m256 maxValues = _mm256_set1_ps(max);
++- __m256 maxValuesIndex = _mm256_setzero_ps();
++- __m256 compareResults;
++- __m256 currentValues;
+++ __m256 indexIncrementValues = _mm256_set1_ps(8);
+++ __m256 currentIndexes = _mm256_set_ps(-1, -2, -3, -4, -5, -6, -7, -8);
++
++- __VOLK_ATTR_ALIGNED(32) float maxValuesBuffer[8];
++- __VOLK_ATTR_ALIGNED(32) float maxIndexesBuffer[8];
+++ float max = src0[0];
+++ float index = 0;
+++ __m256 maxValues = _mm256_set1_ps(max);
+++ __m256 maxValuesIndex = _mm256_setzero_ps();
+++ __m256 compareResults;
+++ __m256 currentValues;
++
++- for(;number < eighthPoints; number++){
+++ __VOLK_ATTR_ALIGNED(32) float maxValuesBuffer[8];
+++ __VOLK_ATTR_ALIGNED(32) float maxIndexesBuffer[8];
++
++- currentValues = _mm256_loadu_ps(inputPtr); inputPtr += 8;
++- currentIndexes = _mm256_add_ps(currentIndexes, indexIncrementValues);
+++ for (; number < eighthPoints; number++) {
++
++- compareResults = _mm256_cmp_ps(currentValues, maxValues, _CMP_GT_OS);
+++ currentValues = _mm256_loadu_ps(inputPtr);
+++ inputPtr += 8;
+++ currentIndexes = _mm256_add_ps(currentIndexes, indexIncrementValues);
++
++- maxValuesIndex = _mm256_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
++- maxValues = _mm256_blendv_ps(maxValues, currentValues, compareResults);
++- }
+++ compareResults = _mm256_cmp_ps(currentValues, maxValues, _CMP_GT_OS);
++
++- // Calculate the largest value from the remaining 4 points
++- _mm256_storeu_ps(maxValuesBuffer, maxValues);
++- _mm256_storeu_ps(maxIndexesBuffer, maxValuesIndex);
+++ maxValuesIndex = _mm256_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
+++ maxValues = _mm256_blendv_ps(maxValues, currentValues, compareResults);
+++ }
++
++- for(number = 0; number < 8; number++){
++- if(maxValuesBuffer[number] > max){
++- index = maxIndexesBuffer[number];
++- max = maxValuesBuffer[number];
++- } else if(maxValuesBuffer[number] == max){
++- if (index > maxIndexesBuffer[number])
++- index = maxIndexesBuffer[number];
+++ // Calculate the largest value from the remaining 4 points
+++ _mm256_storeu_ps(maxValuesBuffer, maxValues);
+++ _mm256_storeu_ps(maxIndexesBuffer, maxValuesIndex);
+++
+++ for (number = 0; number < 8; number++) {
+++ if (maxValuesBuffer[number] > max) {
+++ index = maxIndexesBuffer[number];
+++ max = maxValuesBuffer[number];
+++ } else if (maxValuesBuffer[number] == max) {
+++ if (index > maxIndexesBuffer[number])
+++ index = maxIndexesBuffer[number];
+++ }
++ }
++- }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- if(src0[number] > max){
++- index = number;
++- max = src0[number];
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ if (src0[number] > max) {
+++ index = number;
+++ max = src0[number];
+++ }
++ }
++- }
++- target[0] = (uint16_t)index;
+++ target[0] = (uint16_t)index;
++ }
++
++ #endif /*LV_HAVE_AVX*/
++diff --git a/kernels/volk/volk_32f_index_max_32u.h b/kernels/volk/volk_32f_index_max_32u.h
++index 318c8e4..315531d 100644
++--- a/kernels/volk/volk_32f_index_max_32u.h
+++++ b/kernels/volk/volk_32f_index_max_32u.h
++@@ -25,7 +25,8 @@
++ *
++ * \b Overview
++ *
++- * Returns Argmax_i x[i]. Finds and returns the index which contains the first maximum value in the given vector.
+++ * Returns Argmax_i x[i]. Finds and returns the index which contains the first maximum
+++ * value in the given vector.
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++@@ -64,70 +65,71 @@
++ #ifndef INCLUDED_volk_32f_index_max_32u_a_H
++ #define INCLUDED_volk_32f_index_max_32u_a_H
++
++-#include <volk/volk_common.h>
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_SSE4_1
++-#include<smmintrin.h>
+++#include <smmintrin.h>
++
++ static inline void
++ volk_32f_index_max_32u_a_sse4_1(uint32_t* target, const float* src0, uint32_t num_points)
++ {
++- if(num_points > 0){
++- uint32_t number = 0;
++- const uint32_t quarterPoints = num_points / 4;
+++ if (num_points > 0) {
+++ uint32_t number = 0;
+++ const uint32_t quarterPoints = num_points / 4;
++
++- float* inputPtr = (float*)src0;
+++ float* inputPtr = (float*)src0;
++
++- __m128 indexIncrementValues = _mm_set1_ps(4);
++- __m128 currentIndexes = _mm_set_ps(-1,-2,-3,-4);
+++ __m128 indexIncrementValues = _mm_set1_ps(4);
+++ __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
++
++- float max = src0[0];
++- float index = 0;
++- __m128 maxValues = _mm_set1_ps(max);
++- __m128 maxValuesIndex = _mm_setzero_ps();
++- __m128 compareResults;
++- __m128 currentValues;
+++ float max = src0[0];
+++ float index = 0;
+++ __m128 maxValues = _mm_set1_ps(max);
+++ __m128 maxValuesIndex = _mm_setzero_ps();
+++ __m128 compareResults;
+++ __m128 currentValues;
++
++- __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
++- __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- currentValues = _mm_load_ps(inputPtr); inputPtr += 4;
++- currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
+++ currentValues = _mm_load_ps(inputPtr);
+++ inputPtr += 4;
+++ currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
++
++- compareResults = _mm_cmpgt_ps(currentValues, maxValues);
+++ compareResults = _mm_cmpgt_ps(currentValues, maxValues);
++
++- maxValuesIndex = _mm_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
++- maxValues = _mm_blendv_ps(maxValues, currentValues, compareResults);
++- }
+++ maxValuesIndex =
+++ _mm_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
+++ maxValues = _mm_blendv_ps(maxValues, currentValues, compareResults);
+++ }
++
++- // Calculate the largest value from the remaining 4 points
++- _mm_store_ps(maxValuesBuffer, maxValues);
++- _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
++-
++- for(number = 0; number < 4; number++){
++- if(maxValuesBuffer[number] > max){
++- index = maxIndexesBuffer[number];
++- max = maxValuesBuffer[number];
++- } else if(maxValuesBuffer[number] == max){
++- if (index > maxIndexesBuffer[number])
++- index = maxIndexesBuffer[number];
++- }
++- }
+++ // Calculate the largest value from the remaining 4 points
+++ _mm_store_ps(maxValuesBuffer, maxValues);
+++ _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
+++
+++ for (number = 0; number < 4; number++) {
+++ if (maxValuesBuffer[number] > max) {
+++ index = maxIndexesBuffer[number];
+++ max = maxValuesBuffer[number];
+++ } else if (maxValuesBuffer[number] == max) {
+++ if (index > maxIndexesBuffer[number])
+++ index = maxIndexesBuffer[number];
+++ }
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- if(src0[number] > max){
++- index = number;
++- max = src0[number];
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ if (src0[number] > max) {
+++ index = number;
+++ max = src0[number];
+++ }
+++ }
+++ target[0] = (uint32_t)index;
++ }
++- target[0] = (uint32_t)index;
++- }
++ }
++
++ #endif /*LV_HAVE_SSE4_1*/
++@@ -135,67 +137,68 @@ volk_32f_index_max_32u_a_sse4_1(uint32_t* target, const float* src0, uint32_t nu
++
++ #ifdef LV_HAVE_SSE
++
++-#include<xmmintrin.h>
+++#include <xmmintrin.h>
++
++ static inline void
++ volk_32f_index_max_32u_a_sse(uint32_t* target, const float* src0, uint32_t num_points)
++ {
++- if(num_points > 0){
++- uint32_t number = 0;
++- const uint32_t quarterPoints = num_points / 4;
+++ if (num_points > 0) {
+++ uint32_t number = 0;
+++ const uint32_t quarterPoints = num_points / 4;
++
++- float* inputPtr = (float*)src0;
+++ float* inputPtr = (float*)src0;
++
++- __m128 indexIncrementValues = _mm_set1_ps(4);
++- __m128 currentIndexes = _mm_set_ps(-1,-2,-3,-4);
+++ __m128 indexIncrementValues = _mm_set1_ps(4);
+++ __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
++
++- float max = src0[0];
++- float index = 0;
++- __m128 maxValues = _mm_set1_ps(max);
++- __m128 maxValuesIndex = _mm_setzero_ps();
++- __m128 compareResults;
++- __m128 currentValues;
+++ float max = src0[0];
+++ float index = 0;
+++ __m128 maxValues = _mm_set1_ps(max);
+++ __m128 maxValuesIndex = _mm_setzero_ps();
+++ __m128 compareResults;
+++ __m128 currentValues;
++
++- __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
++- __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- currentValues = _mm_load_ps(inputPtr); inputPtr += 4;
++- currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
+++ currentValues = _mm_load_ps(inputPtr);
+++ inputPtr += 4;
+++ currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
++
++- compareResults = _mm_cmpgt_ps(currentValues, maxValues);
+++ compareResults = _mm_cmpgt_ps(currentValues, maxValues);
++
++- maxValuesIndex = _mm_or_ps(_mm_and_ps(compareResults, currentIndexes),
++- _mm_andnot_ps(compareResults, maxValuesIndex));
+++ maxValuesIndex = _mm_or_ps(_mm_and_ps(compareResults, currentIndexes),
+++ _mm_andnot_ps(compareResults, maxValuesIndex));
++
++- maxValues = _mm_or_ps(_mm_and_ps(compareResults, currentValues),
++- _mm_andnot_ps(compareResults, maxValues));
++- }
+++ maxValues = _mm_or_ps(_mm_and_ps(compareResults, currentValues),
+++ _mm_andnot_ps(compareResults, maxValues));
+++ }
++
++- // Calculate the largest value from the remaining 4 points
++- _mm_store_ps(maxValuesBuffer, maxValues);
++- _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
++-
++- for(number = 0; number < 4; number++){
++- if(maxValuesBuffer[number] > max){
++- index = maxIndexesBuffer[number];
++- max = maxValuesBuffer[number];
++- } else if(maxValuesBuffer[number] == max){
++- if (index > maxIndexesBuffer[number])
++- index = maxIndexesBuffer[number];
++- }
++- }
+++ // Calculate the largest value from the remaining 4 points
+++ _mm_store_ps(maxValuesBuffer, maxValues);
+++ _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
+++
+++ for (number = 0; number < 4; number++) {
+++ if (maxValuesBuffer[number] > max) {
+++ index = maxIndexesBuffer[number];
+++ max = maxValuesBuffer[number];
+++ } else if (maxValuesBuffer[number] == max) {
+++ if (index > maxIndexesBuffer[number])
+++ index = maxIndexesBuffer[number];
+++ }
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- if(src0[number] > max){
++- index = number;
++- max = src0[number];
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ if (src0[number] > max) {
+++ index = number;
+++ max = src0[number];
+++ }
+++ }
+++ target[0] = (uint32_t)index;
++ }
++- target[0] = (uint32_t)index;
++- }
++ }
++
++ #endif /*LV_HAVE_SSE*/
++@@ -204,65 +207,61 @@ volk_32f_index_max_32u_a_sse(uint32_t* target, const float* src0, uint32_t num_p
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32f_index_max_32u_a_avx(uint32_t* target, const float* src0, uint32_t num_points)
+++static inline void
+++volk_32f_index_max_32u_a_avx(uint32_t* target, const float* src0, uint32_t num_points)
++ {
++- if(num_points > 0)
++- {
++- uint32_t number = 0;
++- const uint32_t quarterPoints = num_points / 8;
++-
++- float* inputPtr = (float*)src0;
++-
++- __m256 indexIncrementValues = _mm256_set1_ps(8);
++- __m256 currentIndexes = _mm256_set_ps(-1,-2,-3,-4,-5,-6,-7,-8);
++-
++- float max = src0[0];
++- float index = 0;
++- __m256 maxValues = _mm256_set1_ps(max);
++- __m256 maxValuesIndex = _mm256_setzero_ps();
++- __m256 compareResults;
++- __m256 currentValues;
++-
++- __VOLK_ATTR_ALIGNED(32) float maxValuesBuffer[8];
++- __VOLK_ATTR_ALIGNED(32) float maxIndexesBuffer[8];
++-
++- for(;number < quarterPoints; number++)
++- {
++- currentValues = _mm256_load_ps(inputPtr); inputPtr += 8;
++- currentIndexes = _mm256_add_ps(currentIndexes, indexIncrementValues);
++- compareResults = _mm256_cmp_ps(currentValues, maxValues, _CMP_GT_OS);
++- maxValuesIndex = _mm256_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
++- maxValues = _mm256_blendv_ps(maxValues, currentValues, compareResults);
++- }
++-
++- // Calculate the largest value from the remaining 8 points
++- _mm256_store_ps(maxValuesBuffer, maxValues);
++- _mm256_store_ps(maxIndexesBuffer, maxValuesIndex);
++-
++- for(number = 0; number < 8; number++)
++- {
++- if(maxValuesBuffer[number] > max)
++- {
++- index = maxIndexesBuffer[number];
++- max = maxValuesBuffer[number];
++- }
++- else if(maxValuesBuffer[number] == max){
++- if (index > maxIndexesBuffer[number])
++- index = maxIndexesBuffer[number];
++- }
++- }
++-
++- number = quarterPoints * 8;
++- for(;number < num_points; number++)
++- {
++- if(src0[number] > max)
++- {
++- index = number;
++- max = src0[number];
++- }
++- }
++- target[0] = (uint32_t)index;
+++ if (num_points > 0) {
+++ uint32_t number = 0;
+++ const uint32_t quarterPoints = num_points / 8;
+++
+++ float* inputPtr = (float*)src0;
+++
+++ __m256 indexIncrementValues = _mm256_set1_ps(8);
+++ __m256 currentIndexes = _mm256_set_ps(-1, -2, -3, -4, -5, -6, -7, -8);
+++
+++ float max = src0[0];
+++ float index = 0;
+++ __m256 maxValues = _mm256_set1_ps(max);
+++ __m256 maxValuesIndex = _mm256_setzero_ps();
+++ __m256 compareResults;
+++ __m256 currentValues;
+++
+++ __VOLK_ATTR_ALIGNED(32) float maxValuesBuffer[8];
+++ __VOLK_ATTR_ALIGNED(32) float maxIndexesBuffer[8];
+++
+++ for (; number < quarterPoints; number++) {
+++ currentValues = _mm256_load_ps(inputPtr);
+++ inputPtr += 8;
+++ currentIndexes = _mm256_add_ps(currentIndexes, indexIncrementValues);
+++ compareResults = _mm256_cmp_ps(currentValues, maxValues, _CMP_GT_OS);
+++ maxValuesIndex =
+++ _mm256_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
+++ maxValues = _mm256_blendv_ps(maxValues, currentValues, compareResults);
+++ }
+++
+++ // Calculate the largest value from the remaining 8 points
+++ _mm256_store_ps(maxValuesBuffer, maxValues);
+++ _mm256_store_ps(maxIndexesBuffer, maxValuesIndex);
+++
+++ for (number = 0; number < 8; number++) {
+++ if (maxValuesBuffer[number] > max) {
+++ index = maxIndexesBuffer[number];
+++ max = maxValuesBuffer[number];
+++ } else if (maxValuesBuffer[number] == max) {
+++ if (index > maxIndexesBuffer[number])
+++ index = maxIndexesBuffer[number];
+++ }
+++ }
+++
+++ number = quarterPoints * 8;
+++ for (; number < num_points; number++) {
+++ if (src0[number] > max) {
+++ index = number;
+++ max = src0[number];
+++ }
++ }
+++ target[0] = (uint32_t)index;
+++ }
++ }
++
++ #endif /*LV_HAVE_AVX*/
++@@ -271,66 +270,63 @@ static inline void volk_32f_index_max_32u_a_avx(uint32_t* target, const float* s
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_32f_index_max_32u_neon(uint32_t* target, const float* src0, uint32_t num_points)
+++static inline void
+++volk_32f_index_max_32u_neon(uint32_t* target, const float* src0, uint32_t num_points)
++ {
++- if(num_points > 0)
++- {
++- uint32_t number = 0;
++- const uint32_t quarterPoints = num_points / 4;
++-
++- float* inputPtr = (float*)src0;
++- float32x4_t indexIncrementValues = vdupq_n_f32(4);
++- __VOLK_ATTR_ALIGNED(16) float currentIndexes_float[4] = { -4.0f, -3.0f, -2.0f, -1.0f };
++- float32x4_t currentIndexes = vld1q_f32(currentIndexes_float);
++-
++- float max = src0[0];
++- float index = 0;
++- float32x4_t maxValues = vdupq_n_f32(max);
++- uint32x4_t maxValuesIndex = vmovq_n_u32(0);
++- uint32x4_t compareResults;
++- uint32x4_t currentIndexes_u;
++- float32x4_t currentValues;
++-
++- __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
++- __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
++-
++- for(;number < quarterPoints; number++)
++- {
++- currentValues = vld1q_f32(inputPtr); inputPtr += 4;
++- currentIndexes = vaddq_f32(currentIndexes, indexIncrementValues);
++- currentIndexes_u = vcvtq_u32_f32(currentIndexes);
++- compareResults = vcleq_f32(currentValues, maxValues);
++- maxValuesIndex = vorrq_u32( vandq_u32( compareResults, maxValuesIndex ), vbicq_u32(currentIndexes_u, compareResults) );
++- maxValues = vmaxq_f32(currentValues, maxValues);
++- }
++-
++- // Calculate the largest value from the remaining 4 points
++- vst1q_f32(maxValuesBuffer, maxValues);
++- vst1q_f32(maxIndexesBuffer, vcvtq_f32_u32(maxValuesIndex));
++- for(number = 0; number < 4; number++)
++- {
++- if(maxValuesBuffer[number] > max)
++- {
++- index = maxIndexesBuffer[number];
++- max = maxValuesBuffer[number];
++- }
++- else if(maxValues[number] == max){
++- if (index > maxIndexesBuffer[number])
++- index = maxIndexesBuffer[number];
++- }
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++)
++- {
++- if(src0[number] > max)
++- {
++- index = number;
++- max = src0[number];
++- }
++- }
++- target[0] = (uint32_t)index;
+++ if (num_points > 0) {
+++ uint32_t number = 0;
+++ const uint32_t quarterPoints = num_points / 4;
+++
+++ float* inputPtr = (float*)src0;
+++ float32x4_t indexIncrementValues = vdupq_n_f32(4);
+++ __VOLK_ATTR_ALIGNED(16)
+++ float currentIndexes_float[4] = { -4.0f, -3.0f, -2.0f, -1.0f };
+++ float32x4_t currentIndexes = vld1q_f32(currentIndexes_float);
+++
+++ float max = src0[0];
+++ float index = 0;
+++ float32x4_t maxValues = vdupq_n_f32(max);
+++ uint32x4_t maxValuesIndex = vmovq_n_u32(0);
+++ uint32x4_t compareResults;
+++ uint32x4_t currentIndexes_u;
+++ float32x4_t currentValues;
+++
+++ __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
+++
+++ for (; number < quarterPoints; number++) {
+++ currentValues = vld1q_f32(inputPtr);
+++ inputPtr += 4;
+++ currentIndexes = vaddq_f32(currentIndexes, indexIncrementValues);
+++ currentIndexes_u = vcvtq_u32_f32(currentIndexes);
+++ compareResults = vcleq_f32(currentValues, maxValues);
+++ maxValuesIndex = vorrq_u32(vandq_u32(compareResults, maxValuesIndex),
+++ vbicq_u32(currentIndexes_u, compareResults));
+++ maxValues = vmaxq_f32(currentValues, maxValues);
+++ }
+++
+++ // Calculate the largest value from the remaining 4 points
+++ vst1q_f32(maxValuesBuffer, maxValues);
+++ vst1q_f32(maxIndexesBuffer, vcvtq_f32_u32(maxValuesIndex));
+++ for (number = 0; number < 4; number++) {
+++ if (maxValuesBuffer[number] > max) {
+++ index = maxIndexesBuffer[number];
+++ max = maxValuesBuffer[number];
+++ } else if (maxValues[number] == max) {
+++ if (index > maxIndexesBuffer[number])
+++ index = maxIndexesBuffer[number];
+++ }
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ if (src0[number] > max) {
+++ index = number;
+++ max = src0[number];
+++ }
++ }
+++ target[0] = (uint32_t)index;
+++ }
++ }
++
++ #endif /*LV_HAVE_NEON*/
++@@ -341,20 +337,20 @@ static inline void volk_32f_index_max_32u_neon(uint32_t* target, const float* sr
++ static inline void
++ volk_32f_index_max_32u_generic(uint32_t* target, const float* src0, uint32_t num_points)
++ {
++- if(num_points > 0){
++- float max = src0[0];
++- uint32_t index = 0;
+++ if (num_points > 0) {
+++ float max = src0[0];
+++ uint32_t index = 0;
++
++- uint32_t i = 1;
+++ uint32_t i = 1;
++
++- for(; i < num_points; ++i) {
++- if(src0[i] > max){
++- index = i;
++- max = src0[i];
++- }
+++ for (; i < num_points; ++i) {
+++ if (src0[i] > max) {
+++ index = i;
+++ max = src0[i];
+++ }
+++ }
+++ target[0] = index;
++ }
++- target[0] = index;
++- }
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -366,209 +362,195 @@ volk_32f_index_max_32u_generic(uint32_t* target, const float* src0, uint32_t num
++ #ifndef INCLUDED_volk_32f_index_max_32u_u_H
++ #define INCLUDED_volk_32f_index_max_32u_u_H
++
++-#include <volk/volk_common.h>
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32f_index_max_32u_u_avx(uint32_t* target, const float* src0, uint32_t num_points)
+++static inline void
+++volk_32f_index_max_32u_u_avx(uint32_t* target, const float* src0, uint32_t num_points)
++ {
++- if(num_points > 0)
++- {
++- uint32_t number = 0;
++- const uint32_t quarterPoints = num_points / 8;
++-
++- float* inputPtr = (float*)src0;
++-
++- __m256 indexIncrementValues = _mm256_set1_ps(8);
++- __m256 currentIndexes = _mm256_set_ps(-1,-2,-3,-4,-5,-6,-7,-8);
++-
++- float max = src0[0];
++- float index = 0;
++- __m256 maxValues = _mm256_set1_ps(max);
++- __m256 maxValuesIndex = _mm256_setzero_ps();
++- __m256 compareResults;
++- __m256 currentValues;
++-
++- __VOLK_ATTR_ALIGNED(32) float maxValuesBuffer[8];
++- __VOLK_ATTR_ALIGNED(32) float maxIndexesBuffer[8];
++-
++- for(;number < quarterPoints; number++)
++- {
++- currentValues = _mm256_loadu_ps(inputPtr); inputPtr += 8;
++- currentIndexes = _mm256_add_ps(currentIndexes, indexIncrementValues);
++- compareResults = _mm256_cmp_ps(currentValues, maxValues, _CMP_GT_OS);
++- maxValuesIndex = _mm256_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
++- maxValues = _mm256_blendv_ps(maxValues, currentValues, compareResults);
++- }
++-
++- // Calculate the largest value from the remaining 8 points
++- _mm256_store_ps(maxValuesBuffer, maxValues);
++- _mm256_store_ps(maxIndexesBuffer, maxValuesIndex);
++-
++- for(number = 0; number < 8; number++)
++- {
++- if(maxValuesBuffer[number] > max)
++- {
++- index = maxIndexesBuffer[number];
++- max = maxValuesBuffer[number];
++- }
++- else if(maxValuesBuffer[number] == max){
++- if (index > maxIndexesBuffer[number])
++- index = maxIndexesBuffer[number];
++- }
++- }
++-
++- number = quarterPoints * 8;
++- for(;number < num_points; number++)
++- {
++- if(src0[number] > max)
++- {
++- index = number;
++- max = src0[number];
++- }
++- }
++- target[0] = (uint32_t)index;
+++ if (num_points > 0) {
+++ uint32_t number = 0;
+++ const uint32_t quarterPoints = num_points / 8;
+++
+++ float* inputPtr = (float*)src0;
+++
+++ __m256 indexIncrementValues = _mm256_set1_ps(8);
+++ __m256 currentIndexes = _mm256_set_ps(-1, -2, -3, -4, -5, -6, -7, -8);
+++
+++ float max = src0[0];
+++ float index = 0;
+++ __m256 maxValues = _mm256_set1_ps(max);
+++ __m256 maxValuesIndex = _mm256_setzero_ps();
+++ __m256 compareResults;
+++ __m256 currentValues;
+++
+++ __VOLK_ATTR_ALIGNED(32) float maxValuesBuffer[8];
+++ __VOLK_ATTR_ALIGNED(32) float maxIndexesBuffer[8];
+++
+++ for (; number < quarterPoints; number++) {
+++ currentValues = _mm256_loadu_ps(inputPtr);
+++ inputPtr += 8;
+++ currentIndexes = _mm256_add_ps(currentIndexes, indexIncrementValues);
+++ compareResults = _mm256_cmp_ps(currentValues, maxValues, _CMP_GT_OS);
+++ maxValuesIndex =
+++ _mm256_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
+++ maxValues = _mm256_blendv_ps(maxValues, currentValues, compareResults);
++ }
+++
+++ // Calculate the largest value from the remaining 8 points
+++ _mm256_store_ps(maxValuesBuffer, maxValues);
+++ _mm256_store_ps(maxIndexesBuffer, maxValuesIndex);
+++
+++ for (number = 0; number < 8; number++) {
+++ if (maxValuesBuffer[number] > max) {
+++ index = maxIndexesBuffer[number];
+++ max = maxValuesBuffer[number];
+++ } else if (maxValuesBuffer[number] == max) {
+++ if (index > maxIndexesBuffer[number])
+++ index = maxIndexesBuffer[number];
+++ }
+++ }
+++
+++ number = quarterPoints * 8;
+++ for (; number < num_points; number++) {
+++ if (src0[number] > max) {
+++ index = number;
+++ max = src0[number];
+++ }
+++ }
+++ target[0] = (uint32_t)index;
+++ }
++ }
++
++ #endif /*LV_HAVE_AVX*/
++
++
++ #ifdef LV_HAVE_SSE4_1
++-#include<smmintrin.h>
+++#include <smmintrin.h>
++
++-static inline void volk_32f_index_max_32u_u_sse4_1(uint32_t* target, const float* src0, uint32_t num_points)
+++static inline void
+++volk_32f_index_max_32u_u_sse4_1(uint32_t* target, const float* src0, uint32_t num_points)
++ {
++- if(num_points > 0)
++- {
++- uint32_t number = 0;
++- const uint32_t quarterPoints = num_points / 4;
++-
++- float* inputPtr = (float*)src0;
++-
++- __m128 indexIncrementValues = _mm_set1_ps(4);
++- __m128 currentIndexes = _mm_set_ps(-1,-2,-3,-4);
++-
++- float max = src0[0];
++- float index = 0;
++- __m128 maxValues = _mm_set1_ps(max);
++- __m128 maxValuesIndex = _mm_setzero_ps();
++- __m128 compareResults;
++- __m128 currentValues;
++-
++- __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
++- __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
++-
++- for(;number < quarterPoints; number++)
++- {
++- currentValues = _mm_loadu_ps(inputPtr); inputPtr += 4;
++- currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
++- compareResults = _mm_cmpgt_ps(currentValues, maxValues);
++- maxValuesIndex = _mm_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
++- maxValues = _mm_blendv_ps(maxValues, currentValues, compareResults);
++- }
++-
++- // Calculate the largest value from the remaining 4 points
++- _mm_store_ps(maxValuesBuffer, maxValues);
++- _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
++-
++- for(number = 0; number < 4; number++)
++- {
++- if(maxValuesBuffer[number] > max)
++- {
++- index = maxIndexesBuffer[number];
++- max = maxValuesBuffer[number];
++- }
++- else if(maxValuesBuffer[number] == max){
++- if (index > maxIndexesBuffer[number])
++- index = maxIndexesBuffer[number];
++- }
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++)
++- {
++- if(src0[number] > max)
++- {
++- index = number;
++- max = src0[number];
++- }
++- }
++- target[0] = (uint32_t)index;
+++ if (num_points > 0) {
+++ uint32_t number = 0;
+++ const uint32_t quarterPoints = num_points / 4;
+++
+++ float* inputPtr = (float*)src0;
+++
+++ __m128 indexIncrementValues = _mm_set1_ps(4);
+++ __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
+++
+++ float max = src0[0];
+++ float index = 0;
+++ __m128 maxValues = _mm_set1_ps(max);
+++ __m128 maxValuesIndex = _mm_setzero_ps();
+++ __m128 compareResults;
+++ __m128 currentValues;
+++
+++ __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
+++
+++ for (; number < quarterPoints; number++) {
+++ currentValues = _mm_loadu_ps(inputPtr);
+++ inputPtr += 4;
+++ currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
+++ compareResults = _mm_cmpgt_ps(currentValues, maxValues);
+++ maxValuesIndex =
+++ _mm_blendv_ps(maxValuesIndex, currentIndexes, compareResults);
+++ maxValues = _mm_blendv_ps(maxValues, currentValues, compareResults);
++ }
+++
+++ // Calculate the largest value from the remaining 4 points
+++ _mm_store_ps(maxValuesBuffer, maxValues);
+++ _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
+++
+++ for (number = 0; number < 4; number++) {
+++ if (maxValuesBuffer[number] > max) {
+++ index = maxIndexesBuffer[number];
+++ max = maxValuesBuffer[number];
+++ } else if (maxValuesBuffer[number] == max) {
+++ if (index > maxIndexesBuffer[number])
+++ index = maxIndexesBuffer[number];
+++ }
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ if (src0[number] > max) {
+++ index = number;
+++ max = src0[number];
+++ }
+++ }
+++ target[0] = (uint32_t)index;
+++ }
++ }
++
++ #endif /*LV_HAVE_SSE4_1*/
++
++ #ifdef LV_HAVE_SSE
++-#include<xmmintrin.h>
+++#include <xmmintrin.h>
++
++-static inline void volk_32f_index_max_32u_u_sse(uint32_t* target, const float* src0, uint32_t num_points)
+++static inline void
+++volk_32f_index_max_32u_u_sse(uint32_t* target, const float* src0, uint32_t num_points)
++ {
++- if(num_points > 0)
++- {
++- uint32_t number = 0;
++- const uint32_t quarterPoints = num_points / 4;
++-
++- float* inputPtr = (float*)src0;
++-
++- __m128 indexIncrementValues = _mm_set1_ps(4);
++- __m128 currentIndexes = _mm_set_ps(-1,-2,-3,-4);
++-
++- float max = src0[0];
++- float index = 0;
++- __m128 maxValues = _mm_set1_ps(max);
++- __m128 maxValuesIndex = _mm_setzero_ps();
++- __m128 compareResults;
++- __m128 currentValues;
++-
++- __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
++- __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
++-
++- for(;number < quarterPoints; number++)
++- {
++- currentValues = _mm_loadu_ps(inputPtr); inputPtr += 4;
++- currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
++- compareResults = _mm_cmpgt_ps(currentValues, maxValues);
++- maxValuesIndex = _mm_or_ps(_mm_and_ps(compareResults, currentIndexes),
++- _mm_andnot_ps(compareResults, maxValuesIndex));
++- maxValues = _mm_or_ps(_mm_and_ps(compareResults, currentValues),
++- _mm_andnot_ps(compareResults, maxValues));
++- }
++-
++- // Calculate the largest value from the remaining 4 points
++- _mm_store_ps(maxValuesBuffer, maxValues);
++- _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
++-
++- for(number = 0; number < 4; number++)
++- {
++- if(maxValuesBuffer[number] > max)
++- {
++- index = maxIndexesBuffer[number];
++- max = maxValuesBuffer[number];
++- }
++- else if(maxValuesBuffer[number] == max){
++- if (index > maxIndexesBuffer[number])
++- index = maxIndexesBuffer[number];
++- }
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++)
++- {
++- if(src0[number] > max)
++- {
++- index = number;
++- max = src0[number];
++- }
++- }
++- target[0] = (uint32_t)index;
+++ if (num_points > 0) {
+++ uint32_t number = 0;
+++ const uint32_t quarterPoints = num_points / 4;
+++
+++ float* inputPtr = (float*)src0;
+++
+++ __m128 indexIncrementValues = _mm_set1_ps(4);
+++ __m128 currentIndexes = _mm_set_ps(-1, -2, -3, -4);
+++
+++ float max = src0[0];
+++ float index = 0;
+++ __m128 maxValues = _mm_set1_ps(max);
+++ __m128 maxValuesIndex = _mm_setzero_ps();
+++ __m128 compareResults;
+++ __m128 currentValues;
+++
+++ __VOLK_ATTR_ALIGNED(16) float maxValuesBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float maxIndexesBuffer[4];
+++
+++ for (; number < quarterPoints; number++) {
+++ currentValues = _mm_loadu_ps(inputPtr);
+++ inputPtr += 4;
+++ currentIndexes = _mm_add_ps(currentIndexes, indexIncrementValues);
+++ compareResults = _mm_cmpgt_ps(currentValues, maxValues);
+++ maxValuesIndex = _mm_or_ps(_mm_and_ps(compareResults, currentIndexes),
+++ _mm_andnot_ps(compareResults, maxValuesIndex));
+++ maxValues = _mm_or_ps(_mm_and_ps(compareResults, currentValues),
+++ _mm_andnot_ps(compareResults, maxValues));
++ }
+++
+++ // Calculate the largest value from the remaining 4 points
+++ _mm_store_ps(maxValuesBuffer, maxValues);
+++ _mm_store_ps(maxIndexesBuffer, maxValuesIndex);
+++
+++ for (number = 0; number < 4; number++) {
+++ if (maxValuesBuffer[number] > max) {
+++ index = maxIndexesBuffer[number];
+++ max = maxValuesBuffer[number];
+++ } else if (maxValuesBuffer[number] == max) {
+++ if (index > maxIndexesBuffer[number])
+++ index = maxIndexesBuffer[number];
+++ }
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ if (src0[number] > max) {
+++ index = number;
+++ max = src0[number];
+++ }
+++ }
+++ target[0] = (uint32_t)index;
+++ }
++ }
++
++ #endif /*LV_HAVE_SSE*/
++diff --git a/kernels/volk/volk_32f_invsqrt_32f.h b/kernels/volk/volk_32f_invsqrt_32f.h
++index e416321..e545515 100644
++--- a/kernels/volk/volk_32f_invsqrt_32f.h
+++++ b/kernels/volk/volk_32f_invsqrt_32f.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_invsqrt_32f(float* cVector, const float* aVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_invsqrt_32f(float* cVector, const float* aVector, unsigned int
+++ * num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: the input vector of floats.
++@@ -66,27 +66,27 @@
++ #define INCLUDED_volk_32f_invsqrt_32f_a_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++ #include <string.h>
++
++-static inline float
++-Q_rsqrt(float number)
+++static inline float Q_rsqrt(float number)
++ {
++- float x2;
++- const float threehalfs = 1.5F;
++- union f32_to_i32 {
++- int32_t i;
++- float f;
++- } u;
++-
++- x2 = number * 0.5F;
++- u.f = number;
++- u.i = 0x5f3759df - ( u.i >> 1 ); // what the fuck?
++- u.f = u.f * ( threehalfs - ( x2 * u.f * u.f ) ); // 1st iteration
++- //u.f = u.f * ( threehalfs - ( x2 * u.f * u.f ) ); // 2nd iteration, this can be removed
++-
++- return u.f;
+++ float x2;
+++ const float threehalfs = 1.5F;
+++ union f32_to_i32 {
+++ int32_t i;
+++ float f;
+++ } u;
+++
+++ x2 = number * 0.5F;
+++ u.f = number;
+++ u.i = 0x5f3759df - (u.i >> 1); // what the fuck?
+++ u.f = u.f * (threehalfs - (x2 * u.f * u.f)); // 1st iteration
+++ // u.f = u.f * ( threehalfs - ( x2 * u.f * u.f ) ); // 2nd iteration, this can be
+++ // removed
+++
+++ return u.f;
++ }
++
++ #ifdef LV_HAVE_AVX
++@@ -95,24 +95,23 @@ Q_rsqrt(float number)
++ static inline void
++ volk_32f_invsqrt_32f_a_avx(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- __m256 aVal, cVal;
++- for (; number < eighthPoints; number++) {
++- aVal = _mm256_load_ps(aPtr);
++- cVal = _mm256_rsqrt_ps(aVal);
++- _mm256_store_ps(cPtr, cVal);
++- aPtr += 8;
++- cPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++)
++- *cPtr++ = Q_rsqrt(*aPtr++);
++-
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ __m256 aVal, cVal;
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ cVal = _mm256_rsqrt_ps(aVal);
+++ _mm256_store_ps(cPtr, cVal);
+++ aPtr += 8;
+++ cPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++)
+++ *cPtr++ = Q_rsqrt(*aPtr++);
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -123,29 +122,29 @@ volk_32f_invsqrt_32f_a_avx(float* cVector, const float* aVector, unsigned int nu
++ static inline void
++ volk_32f_invsqrt_32f_a_sse(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
++
++- __m128 aVal, cVal;
++- for(;number < quarterPoints; number++){
+++ __m128 aVal, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm_load_ps(aPtr);
+++ aVal = _mm_load_ps(aPtr);
++
++- cVal = _mm_rsqrt_ps(aVal);
+++ cVal = _mm_rsqrt_ps(aVal);
++
++- _mm_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++) {
++- *cPtr++ = Q_rsqrt(*aPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = Q_rsqrt(*aPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -156,37 +155,38 @@ volk_32f_invsqrt_32f_a_sse(float* cVector, const float* aVector, unsigned int nu
++ static inline void
++ volk_32f_invsqrt_32f_neon(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number;
++- const unsigned int quarter_points = num_points / 4;
++-
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- float32x4_t a_val, c_val;
++- for (number = 0; number < quarter_points; ++number) {
++- a_val = vld1q_f32(aPtr);
++- c_val = vrsqrteq_f32(a_val);
++- vst1q_f32(cPtr, c_val);
++- aPtr += 4;
++- cPtr += 4;
++- }
++-
++- for(number=quarter_points * 4;number < num_points; number++)
++- *cPtr++ = Q_rsqrt(*aPtr++);
+++ unsigned int number;
+++ const unsigned int quarter_points = num_points / 4;
+++
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ float32x4_t a_val, c_val;
+++ for (number = 0; number < quarter_points; ++number) {
+++ a_val = vld1q_f32(aPtr);
+++ c_val = vrsqrteq_f32(a_val);
+++ vst1q_f32(cPtr, c_val);
+++ aPtr += 4;
+++ cPtr += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++)
+++ *cPtr++ = Q_rsqrt(*aPtr++);
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_invsqrt_32f_generic(float* cVector, const float* aVector, unsigned int num_points)
+++static inline void volk_32f_invsqrt_32f_generic(float* cVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++- for(number = 0; number < num_points; number++) {
++- *cPtr++ = Q_rsqrt(*aPtr++);
++- }
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = Q_rsqrt(*aPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -196,24 +196,23 @@ volk_32f_invsqrt_32f_generic(float* cVector, const float* aVector, unsigned int
++ static inline void
++ volk_32f_invsqrt_32f_u_avx(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- __m256 aVal, cVal;
++- for (; number < eighthPoints; number++) {
++- aVal = _mm256_loadu_ps(aPtr);
++- cVal = _mm256_rsqrt_ps(aVal);
++- _mm256_storeu_ps(cPtr, cVal);
++- aPtr += 8;
++- cPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++)
++- *cPtr++ = Q_rsqrt(*aPtr++);
++-
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ __m256 aVal, cVal;
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ cVal = _mm256_rsqrt_ps(aVal);
+++ _mm256_storeu_ps(cPtr, cVal);
+++ aPtr += 8;
+++ cPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++)
+++ *cPtr++ = Q_rsqrt(*aPtr++);
++ }
++ #endif /* LV_HAVE_AVX */
++
++diff --git a/kernels/volk/volk_32f_log2_32f.h b/kernels/volk/volk_32f_log2_32f.h
++index 740f89d..47276d4 100644
++--- a/kernels/volk/volk_32f_log2_32f.h
+++++ b/kernels/volk/volk_32f_log2_32f.h
++@@ -92,17 +92,18 @@
++ #ifndef INCLUDED_volk_32f_log2_32f_a_H
++ #define INCLUDED_volk_32f_log2_32f_a_H
++
++-#include <stdio.h>
++-#include <stdlib.h>
++ #include <inttypes.h>
++ #include <math.h>
+++#include <stdio.h>
+++#include <stdlib.h>
++
++ #define LOG_POLY_DEGREE 6
++
++ // +-Inf -> +-127.0f in order to match the behaviour of the SIMD kernels
++-static inline float log2f_non_ieee(float f) {
++- float const result = log2f(f);
++- return isinf(result) ? copysignf(127.0f, result) : result;
+++static inline float log2f_non_ieee(float f)
+++{
+++ float const result = log2f(f);
+++ return isinf(result) ? copysignf(127.0f, result) : result;
++ }
++
++ #ifdef LV_HAVE_GENERIC
++@@ -110,12 +111,12 @@ static inline float log2f_non_ieee(float f) {
++ static inline void
++ volk_32f_log2_32f_generic(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++)
++- *bPtr++ = log2f_non_ieee(*aPtr++);
+++ for (number = 0; number < num_points; number++)
+++ *bPtr++ = log2f_non_ieee(*aPtr++);
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -123,56 +124,86 @@ volk_32f_log2_32f_generic(float* bVector, const float* aVector, unsigned int num
++ #include <immintrin.h>
++
++ #define POLY0_FMAAVX2(x, c0) _mm256_set1_ps(c0)
++-#define POLY1_FMAAVX2(x, c0, c1) _mm256_fmadd_ps(POLY0_FMAAVX2(x, c1), x, _mm256_set1_ps(c0))
++-#define POLY2_FMAAVX2(x, c0, c1, c2) _mm256_fmadd_ps(POLY1_FMAAVX2(x, c1, c2), x, _mm256_set1_ps(c0))
++-#define POLY3_FMAAVX2(x, c0, c1, c2, c3) _mm256_fmadd_ps(POLY2_FMAAVX2(x, c1, c2, c3), x, _mm256_set1_ps(c0))
++-#define POLY4_FMAAVX2(x, c0, c1, c2, c3, c4) _mm256_fmadd_ps(POLY3_FMAAVX2(x, c1, c2, c3, c4), x, _mm256_set1_ps(c0))
++-#define POLY5_FMAAVX2(x, c0, c1, c2, c3, c4, c5) _mm256_fmadd_ps(POLY4_FMAAVX2(x, c1, c2, c3, c4, c5), x, _mm256_set1_ps(c0))
++-
++-static inline void
++-volk_32f_log2_32f_a_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
+++#define POLY1_FMAAVX2(x, c0, c1) \
+++ _mm256_fmadd_ps(POLY0_FMAAVX2(x, c1), x, _mm256_set1_ps(c0))
+++#define POLY2_FMAAVX2(x, c0, c1, c2) \
+++ _mm256_fmadd_ps(POLY1_FMAAVX2(x, c1, c2), x, _mm256_set1_ps(c0))
+++#define POLY3_FMAAVX2(x, c0, c1, c2, c3) \
+++ _mm256_fmadd_ps(POLY2_FMAAVX2(x, c1, c2, c3), x, _mm256_set1_ps(c0))
+++#define POLY4_FMAAVX2(x, c0, c1, c2, c3, c4) \
+++ _mm256_fmadd_ps(POLY3_FMAAVX2(x, c1, c2, c3, c4), x, _mm256_set1_ps(c0))
+++#define POLY5_FMAAVX2(x, c0, c1, c2, c3, c4, c5) \
+++ _mm256_fmadd_ps(POLY4_FMAAVX2(x, c1, c2, c3, c4, c5), x, _mm256_set1_ps(c0))
+++
+++static inline void volk_32f_log2_32f_a_avx2_fma(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
++
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- __m256 aVal, bVal, mantissa, frac, leadingOne;
++- __m256i bias, exp;
+++ __m256 aVal, bVal, mantissa, frac, leadingOne;
+++ __m256i bias, exp;
++
++- for(;number < eighthPoints; number++){
+++ for (; number < eighthPoints; number++) {
++
++- aVal = _mm256_load_ps(aPtr);
++- bias = _mm256_set1_epi32(127);
++- leadingOne = _mm256_set1_ps(1.0f);
++- exp = _mm256_sub_epi32(_mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal), _mm256_set1_epi32(0x7f800000)), 23), bias);
++- bVal = _mm256_cvtepi32_ps(exp);
+++ aVal = _mm256_load_ps(aPtr);
+++ bias = _mm256_set1_epi32(127);
+++ leadingOne = _mm256_set1_ps(1.0f);
+++ exp = _mm256_sub_epi32(
+++ _mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal),
+++ _mm256_set1_epi32(0x7f800000)),
+++ 23),
+++ bias);
+++ bVal = _mm256_cvtepi32_ps(exp);
++
++- // Now to extract mantissa
++- frac = _mm256_or_ps(leadingOne, _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
+++ // Now to extract mantissa
+++ frac = _mm256_or_ps(
+++ leadingOne,
+++ _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
++
++ #if LOG_POLY_DEGREE == 6
++- mantissa = POLY5_FMAAVX2( frac, 3.1157899f, -3.3241990f, 2.5988452f, -1.2315303f, 3.1821337e-1f, -3.4436006e-2f);
+++ mantissa = POLY5_FMAAVX2(frac,
+++ 3.1157899f,
+++ -3.3241990f,
+++ 2.5988452f,
+++ -1.2315303f,
+++ 3.1821337e-1f,
+++ -3.4436006e-2f);
++ #elif LOG_POLY_DEGREE == 5
++- mantissa = POLY4_FMAAVX2( frac, 2.8882704548164776201f, -2.52074962577807006663f, 1.48116647521213171641f, -0.465725644288844778798f, 0.0596515482674574969533f);
+++ mantissa = POLY4_FMAAVX2(frac,
+++ 2.8882704548164776201f,
+++ -2.52074962577807006663f,
+++ 1.48116647521213171641f,
+++ -0.465725644288844778798f,
+++ 0.0596515482674574969533f);
++ #elif LOG_POLY_DEGREE == 4
++- mantissa = POLY3_FMAAVX2( frac, 2.61761038894603480148f, -1.75647175389045657003f, 0.688243882994381274313f, -0.107254423828329604454f);
+++ mantissa = POLY3_FMAAVX2(frac,
+++ 2.61761038894603480148f,
+++ -1.75647175389045657003f,
+++ 0.688243882994381274313f,
+++ -0.107254423828329604454f);
++ #elif LOG_POLY_DEGREE == 3
++- mantissa = POLY2_FMAAVX2( frac, 2.28330284476918490682f, -1.04913055217340124191f, 0.204446009836232697516f);
+++ mantissa = POLY2_FMAAVX2(frac,
+++ 2.28330284476918490682f,
+++ -1.04913055217340124191f,
+++ 0.204446009836232697516f);
++ #else
++ #error
++ #endif
++
++- bVal = _mm256_fmadd_ps(mantissa, _mm256_sub_ps(frac, leadingOne), bVal);
++- _mm256_store_ps(bPtr, bVal);
+++ bVal = _mm256_fmadd_ps(mantissa, _mm256_sub_ps(frac, leadingOne), bVal);
+++ _mm256_store_ps(bPtr, bVal);
++
++- aPtr += 8;
++- bPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- volk_32f_log2_32f_generic(bPtr, aPtr, num_points-number);
+++ number = eighthPoints * 8;
+++ volk_32f_log2_32f_generic(bPtr, aPtr, num_points - number);
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for aligned */
++@@ -181,56 +212,86 @@ volk_32f_log2_32f_a_avx2_fma(float* bVector, const float* aVector, unsigned int
++ #include <immintrin.h>
++
++ #define POLY0_AVX2(x, c0) _mm256_set1_ps(c0)
++-#define POLY1_AVX2(x, c0, c1) _mm256_add_ps(_mm256_mul_ps(POLY0_AVX2(x, c1), x), _mm256_set1_ps(c0))
++-#define POLY2_AVX2(x, c0, c1, c2) _mm256_add_ps(_mm256_mul_ps(POLY1_AVX2(x, c1, c2), x), _mm256_set1_ps(c0))
++-#define POLY3_AVX2(x, c0, c1, c2, c3) _mm256_add_ps(_mm256_mul_ps(POLY2_AVX2(x, c1, c2, c3), x), _mm256_set1_ps(c0))
++-#define POLY4_AVX2(x, c0, c1, c2, c3, c4) _mm256_add_ps(_mm256_mul_ps(POLY3_AVX2(x, c1, c2, c3, c4), x), _mm256_set1_ps(c0))
++-#define POLY5_AVX2(x, c0, c1, c2, c3, c4, c5) _mm256_add_ps(_mm256_mul_ps(POLY4_AVX2(x, c1, c2, c3, c4, c5), x), _mm256_set1_ps(c0))
+++#define POLY1_AVX2(x, c0, c1) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY0_AVX2(x, c1), x), _mm256_set1_ps(c0))
+++#define POLY2_AVX2(x, c0, c1, c2) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY1_AVX2(x, c1, c2), x), _mm256_set1_ps(c0))
+++#define POLY3_AVX2(x, c0, c1, c2, c3) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY2_AVX2(x, c1, c2, c3), x), _mm256_set1_ps(c0))
+++#define POLY4_AVX2(x, c0, c1, c2, c3, c4) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY3_AVX2(x, c1, c2, c3, c4), x), _mm256_set1_ps(c0))
+++#define POLY5_AVX2(x, c0, c1, c2, c3, c4, c5) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY4_AVX2(x, c1, c2, c3, c4, c5), x), _mm256_set1_ps(c0))
++
++ static inline void
++ volk_32f_log2_32f_a_avx2(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
++
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- __m256 aVal, bVal, mantissa, frac, leadingOne;
++- __m256i bias, exp;
+++ __m256 aVal, bVal, mantissa, frac, leadingOne;
+++ __m256i bias, exp;
++
++- for(;number < eighthPoints; number++){
+++ for (; number < eighthPoints; number++) {
++
++- aVal = _mm256_load_ps(aPtr);
++- bias = _mm256_set1_epi32(127);
++- leadingOne = _mm256_set1_ps(1.0f);
++- exp = _mm256_sub_epi32(_mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal), _mm256_set1_epi32(0x7f800000)), 23), bias);
++- bVal = _mm256_cvtepi32_ps(exp);
+++ aVal = _mm256_load_ps(aPtr);
+++ bias = _mm256_set1_epi32(127);
+++ leadingOne = _mm256_set1_ps(1.0f);
+++ exp = _mm256_sub_epi32(
+++ _mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal),
+++ _mm256_set1_epi32(0x7f800000)),
+++ 23),
+++ bias);
+++ bVal = _mm256_cvtepi32_ps(exp);
++
++- // Now to extract mantissa
++- frac = _mm256_or_ps(leadingOne, _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
+++ // Now to extract mantissa
+++ frac = _mm256_or_ps(
+++ leadingOne,
+++ _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
++
++ #if LOG_POLY_DEGREE == 6
++- mantissa = POLY5_AVX2( frac, 3.1157899f, -3.3241990f, 2.5988452f, -1.2315303f, 3.1821337e-1f, -3.4436006e-2f);
+++ mantissa = POLY5_AVX2(frac,
+++ 3.1157899f,
+++ -3.3241990f,
+++ 2.5988452f,
+++ -1.2315303f,
+++ 3.1821337e-1f,
+++ -3.4436006e-2f);
++ #elif LOG_POLY_DEGREE == 5
++- mantissa = POLY4_AVX2( frac, 2.8882704548164776201f, -2.52074962577807006663f, 1.48116647521213171641f, -0.465725644288844778798f, 0.0596515482674574969533f);
+++ mantissa = POLY4_AVX2(frac,
+++ 2.8882704548164776201f,
+++ -2.52074962577807006663f,
+++ 1.48116647521213171641f,
+++ -0.465725644288844778798f,
+++ 0.0596515482674574969533f);
++ #elif LOG_POLY_DEGREE == 4
++- mantissa = POLY3_AVX2( frac, 2.61761038894603480148f, -1.75647175389045657003f, 0.688243882994381274313f, -0.107254423828329604454f);
+++ mantissa = POLY3_AVX2(frac,
+++ 2.61761038894603480148f,
+++ -1.75647175389045657003f,
+++ 0.688243882994381274313f,
+++ -0.107254423828329604454f);
++ #elif LOG_POLY_DEGREE == 3
++- mantissa = POLY2_AVX2( frac, 2.28330284476918490682f, -1.04913055217340124191f, 0.204446009836232697516f);
+++ mantissa = POLY2_AVX2(frac,
+++ 2.28330284476918490682f,
+++ -1.04913055217340124191f,
+++ 0.204446009836232697516f);
++ #else
++ #error
++ #endif
++
++- bVal = _mm256_add_ps(_mm256_mul_ps(mantissa, _mm256_sub_ps(frac, leadingOne)), bVal);
++- _mm256_store_ps(bPtr, bVal);
+++ bVal =
+++ _mm256_add_ps(_mm256_mul_ps(mantissa, _mm256_sub_ps(frac, leadingOne)), bVal);
+++ _mm256_store_ps(bPtr, bVal);
++
++- aPtr += 8;
++- bPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- volk_32f_log2_32f_generic(bPtr, aPtr, num_points-number);
+++ number = eighthPoints * 8;
+++ volk_32f_log2_32f_generic(bPtr, aPtr, num_points - number);
++ }
++
++ #endif /* LV_HAVE_AVX2 for aligned */
++@@ -241,54 +302,79 @@ volk_32f_log2_32f_a_avx2(float* bVector, const float* aVector, unsigned int num_
++ #define POLY0(x, c0) _mm_set1_ps(c0)
++ #define POLY1(x, c0, c1) _mm_add_ps(_mm_mul_ps(POLY0(x, c1), x), _mm_set1_ps(c0))
++ #define POLY2(x, c0, c1, c2) _mm_add_ps(_mm_mul_ps(POLY1(x, c1, c2), x), _mm_set1_ps(c0))
++-#define POLY3(x, c0, c1, c2, c3) _mm_add_ps(_mm_mul_ps(POLY2(x, c1, c2, c3), x), _mm_set1_ps(c0))
++-#define POLY4(x, c0, c1, c2, c3, c4) _mm_add_ps(_mm_mul_ps(POLY3(x, c1, c2, c3, c4), x), _mm_set1_ps(c0))
++-#define POLY5(x, c0, c1, c2, c3, c4, c5) _mm_add_ps(_mm_mul_ps(POLY4(x, c1, c2, c3, c4, c5), x), _mm_set1_ps(c0))
+++#define POLY3(x, c0, c1, c2, c3) \
+++ _mm_add_ps(_mm_mul_ps(POLY2(x, c1, c2, c3), x), _mm_set1_ps(c0))
+++#define POLY4(x, c0, c1, c2, c3, c4) \
+++ _mm_add_ps(_mm_mul_ps(POLY3(x, c1, c2, c3, c4), x), _mm_set1_ps(c0))
+++#define POLY5(x, c0, c1, c2, c3, c4, c5) \
+++ _mm_add_ps(_mm_mul_ps(POLY4(x, c1, c2, c3, c4, c5), x), _mm_set1_ps(c0))
++
++ static inline void
++ volk_32f_log2_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
++
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- __m128 aVal, bVal, mantissa, frac, leadingOne;
++- __m128i bias, exp;
+++ __m128 aVal, bVal, mantissa, frac, leadingOne;
+++ __m128i bias, exp;
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm_load_ps(aPtr);
++- bias = _mm_set1_epi32(127);
++- leadingOne = _mm_set1_ps(1.0f);
++- exp = _mm_sub_epi32(_mm_srli_epi32(_mm_and_si128(_mm_castps_si128(aVal), _mm_set1_epi32(0x7f800000)), 23), bias);
++- bVal = _mm_cvtepi32_ps(exp);
+++ aVal = _mm_load_ps(aPtr);
+++ bias = _mm_set1_epi32(127);
+++ leadingOne = _mm_set1_ps(1.0f);
+++ exp = _mm_sub_epi32(
+++ _mm_srli_epi32(
+++ _mm_and_si128(_mm_castps_si128(aVal), _mm_set1_epi32(0x7f800000)), 23),
+++ bias);
+++ bVal = _mm_cvtepi32_ps(exp);
++
++- // Now to extract mantissa
++- frac = _mm_or_ps(leadingOne, _mm_and_ps(aVal, _mm_castsi128_ps(_mm_set1_epi32(0x7fffff))));
+++ // Now to extract mantissa
+++ frac = _mm_or_ps(leadingOne,
+++ _mm_and_ps(aVal, _mm_castsi128_ps(_mm_set1_epi32(0x7fffff))));
++
++ #if LOG_POLY_DEGREE == 6
++- mantissa = POLY5( frac, 3.1157899f, -3.3241990f, 2.5988452f, -1.2315303f, 3.1821337e-1f, -3.4436006e-2f);
+++ mantissa = POLY5(frac,
+++ 3.1157899f,
+++ -3.3241990f,
+++ 2.5988452f,
+++ -1.2315303f,
+++ 3.1821337e-1f,
+++ -3.4436006e-2f);
++ #elif LOG_POLY_DEGREE == 5
++- mantissa = POLY4( frac, 2.8882704548164776201f, -2.52074962577807006663f, 1.48116647521213171641f, -0.465725644288844778798f, 0.0596515482674574969533f);
+++ mantissa = POLY4(frac,
+++ 2.8882704548164776201f,
+++ -2.52074962577807006663f,
+++ 1.48116647521213171641f,
+++ -0.465725644288844778798f,
+++ 0.0596515482674574969533f);
++ #elif LOG_POLY_DEGREE == 4
++- mantissa = POLY3( frac, 2.61761038894603480148f, -1.75647175389045657003f, 0.688243882994381274313f, -0.107254423828329604454f);
+++ mantissa = POLY3(frac,
+++ 2.61761038894603480148f,
+++ -1.75647175389045657003f,
+++ 0.688243882994381274313f,
+++ -0.107254423828329604454f);
++ #elif LOG_POLY_DEGREE == 3
++- mantissa = POLY2( frac, 2.28330284476918490682f, -1.04913055217340124191f, 0.204446009836232697516f);
+++ mantissa = POLY2(frac,
+++ 2.28330284476918490682f,
+++ -1.04913055217340124191f,
+++ 0.204446009836232697516f);
++ #else
++ #error
++ #endif
++
++- bVal = _mm_add_ps(bVal, _mm_mul_ps(mantissa, _mm_sub_ps(frac, leadingOne)));
++- _mm_store_ps(bPtr, bVal);
+++ bVal = _mm_add_ps(bVal, _mm_mul_ps(mantissa, _mm_sub_ps(frac, leadingOne)));
+++ _mm_store_ps(bPtr, bVal);
++
++- aPtr += 4;
++- bPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- volk_32f_log2_32f_generic(bPtr, aPtr, num_points-number);
+++ number = quarterPoints * 4;
+++ volk_32f_log2_32f_generic(bPtr, aPtr, num_points - number);
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for aligned */
++@@ -297,91 +383,91 @@ volk_32f_log2_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int nu
++ #include <arm_neon.h>
++
++ /* these macros allow us to embed logs in other kernels */
++-#define VLOG2Q_NEON_PREAMBLE() \
++- int32x4_t one = vdupq_n_s32(0x000800000); \
++- /* minimax polynomial */ \
++- float32x4_t p0 = vdupq_n_f32(-3.0400402727048585); \
++- float32x4_t p1 = vdupq_n_f32(6.1129631282966113); \
++- float32x4_t p2 = vdupq_n_f32(-5.3419892024633207); \
++- float32x4_t p3 = vdupq_n_f32(3.2865287703753912); \
++- float32x4_t p4 = vdupq_n_f32(-1.2669182593441635); \
++- float32x4_t p5 = vdupq_n_f32(0.2751487703421256); \
++- float32x4_t p6 = vdupq_n_f32(-0.0256910888150985); \
++- int32x4_t exp_mask = vdupq_n_s32(0x7f800000); \
++- int32x4_t sig_mask = vdupq_n_s32(0x007fffff); \
++- int32x4_t exp_bias = vdupq_n_s32(127);
++-
++-
++-#define VLOG2Q_NEON_F32(log2_approx, aval) \
++- int32x4_t exponent_i = vandq_s32(aval, exp_mask); \
++- int32x4_t significand_i = vandq_s32(aval, sig_mask); \
++- exponent_i = vshrq_n_s32(exponent_i, 23); \
++- \
++- /* extract the exponent and significand \
++- we can treat this as fixed point to save ~9% on the \
++- conversion + float add */ \
++- significand_i = vorrq_s32(one, significand_i); \
++- float32x4_t significand_f = vcvtq_n_f32_s32(significand_i,23); \
++- /* debias the exponent and convert to float */ \
++- exponent_i = vsubq_s32(exponent_i, exp_bias); \
++- float32x4_t exponent_f = vcvtq_f32_s32(exponent_i); \
++- \
++- /* put the significand through a polynomial fit of log2(x) [1,2] \
++- add the result to the exponent */ \
++- log2_approx = vaddq_f32(exponent_f, p0); /* p0 */ \
++- float32x4_t tmp1 = vmulq_f32(significand_f, p1); /* p1 * x */ \
++- log2_approx = vaddq_f32(log2_approx, tmp1); \
++- float32x4_t sig_2 = vmulq_f32(significand_f, significand_f); /* x^2 */ \
++- tmp1 = vmulq_f32(sig_2, p2); /* p2 * x^2 */ \
++- log2_approx = vaddq_f32(log2_approx, tmp1); \
++- \
++- float32x4_t sig_3 = vmulq_f32(sig_2, significand_f); /* x^3 */ \
++- tmp1 = vmulq_f32(sig_3, p3); /* p3 * x^3 */ \
++- log2_approx = vaddq_f32(log2_approx, tmp1); \
++- float32x4_t sig_4 = vmulq_f32(sig_2, sig_2); /* x^4 */ \
++- tmp1 = vmulq_f32(sig_4, p4); /* p4 * x^4 */ \
++- log2_approx = vaddq_f32(log2_approx, tmp1); \
++- float32x4_t sig_5 = vmulq_f32(sig_3, sig_2); /* x^5 */ \
++- tmp1 = vmulq_f32(sig_5, p5); /* p5 * x^5 */ \
++- log2_approx = vaddq_f32(log2_approx, tmp1); \
++- float32x4_t sig_6 = vmulq_f32(sig_3, sig_3); /* x^6 */ \
++- tmp1 = vmulq_f32(sig_6, p6); /* p6 * x^6 */ \
++- log2_approx = vaddq_f32(log2_approx, tmp1);
+++#define VLOG2Q_NEON_PREAMBLE() \
+++ int32x4_t one = vdupq_n_s32(0x000800000); \
+++ /* minimax polynomial */ \
+++ float32x4_t p0 = vdupq_n_f32(-3.0400402727048585); \
+++ float32x4_t p1 = vdupq_n_f32(6.1129631282966113); \
+++ float32x4_t p2 = vdupq_n_f32(-5.3419892024633207); \
+++ float32x4_t p3 = vdupq_n_f32(3.2865287703753912); \
+++ float32x4_t p4 = vdupq_n_f32(-1.2669182593441635); \
+++ float32x4_t p5 = vdupq_n_f32(0.2751487703421256); \
+++ float32x4_t p6 = vdupq_n_f32(-0.0256910888150985); \
+++ int32x4_t exp_mask = vdupq_n_s32(0x7f800000); \
+++ int32x4_t sig_mask = vdupq_n_s32(0x007fffff); \
+++ int32x4_t exp_bias = vdupq_n_s32(127);
+++
+++
+++#define VLOG2Q_NEON_F32(log2_approx, aval) \
+++ int32x4_t exponent_i = vandq_s32(aval, exp_mask); \
+++ int32x4_t significand_i = vandq_s32(aval, sig_mask); \
+++ exponent_i = vshrq_n_s32(exponent_i, 23); \
+++ \
+++ /* extract the exponent and significand \
+++ we can treat this as fixed point to save ~9% on the \
+++ conversion + float add */ \
+++ significand_i = vorrq_s32(one, significand_i); \
+++ float32x4_t significand_f = vcvtq_n_f32_s32(significand_i, 23); \
+++ /* debias the exponent and convert to float */ \
+++ exponent_i = vsubq_s32(exponent_i, exp_bias); \
+++ float32x4_t exponent_f = vcvtq_f32_s32(exponent_i); \
+++ \
+++ /* put the significand through a polynomial fit of log2(x) [1,2] \
+++ add the result to the exponent */ \
+++ log2_approx = vaddq_f32(exponent_f, p0); /* p0 */ \
+++ float32x4_t tmp1 = vmulq_f32(significand_f, p1); /* p1 * x */ \
+++ log2_approx = vaddq_f32(log2_approx, tmp1); \
+++ float32x4_t sig_2 = vmulq_f32(significand_f, significand_f); /* x^2 */ \
+++ tmp1 = vmulq_f32(sig_2, p2); /* p2 * x^2 */ \
+++ log2_approx = vaddq_f32(log2_approx, tmp1); \
+++ \
+++ float32x4_t sig_3 = vmulq_f32(sig_2, significand_f); /* x^3 */ \
+++ tmp1 = vmulq_f32(sig_3, p3); /* p3 * x^3 */ \
+++ log2_approx = vaddq_f32(log2_approx, tmp1); \
+++ float32x4_t sig_4 = vmulq_f32(sig_2, sig_2); /* x^4 */ \
+++ tmp1 = vmulq_f32(sig_4, p4); /* p4 * x^4 */ \
+++ log2_approx = vaddq_f32(log2_approx, tmp1); \
+++ float32x4_t sig_5 = vmulq_f32(sig_3, sig_2); /* x^5 */ \
+++ tmp1 = vmulq_f32(sig_5, p5); /* p5 * x^5 */ \
+++ log2_approx = vaddq_f32(log2_approx, tmp1); \
+++ float32x4_t sig_6 = vmulq_f32(sig_3, sig_3); /* x^6 */ \
+++ tmp1 = vmulq_f32(sig_6, p6); /* p6 * x^6 */ \
+++ log2_approx = vaddq_f32(log2_approx, tmp1);
++
++ static inline void
++ volk_32f_log2_32f_neon(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++- unsigned int number;
++- const unsigned int quarterPoints = num_points / 4;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++ unsigned int number;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- int32x4_t aval;
++- float32x4_t log2_approx;
+++ int32x4_t aval;
+++ float32x4_t log2_approx;
++
++- VLOG2Q_NEON_PREAMBLE()
++- // lms
++- //p0 = vdupq_n_f32(-1.649132280361871);
++- //p1 = vdupq_n_f32(1.995047138579499);
++- //p2 = vdupq_n_f32(-0.336914839219728);
+++ VLOG2Q_NEON_PREAMBLE()
+++ // lms
+++ // p0 = vdupq_n_f32(-1.649132280361871);
+++ // p1 = vdupq_n_f32(1.995047138579499);
+++ // p2 = vdupq_n_f32(-0.336914839219728);
++
++- // keep in mind a single precision float is represented as
++- // (-1)^sign * 2^exp * 1.significand, so the log2 is
++- // log2(2^exp * sig) = exponent + log2(1 + significand/(1<<23)
++- for(number = 0; number < quarterPoints; ++number){
++- // load float in to an int register without conversion
++- aval = vld1q_s32((int*)aPtr);
+++ // keep in mind a single precision float is represented as
+++ // (-1)^sign * 2^exp * 1.significand, so the log2 is
+++ // log2(2^exp * sig) = exponent + log2(1 + significand/(1<<23)
+++ for (number = 0; number < quarterPoints; ++number) {
+++ // load float in to an int register without conversion
+++ aval = vld1q_s32((int*)aPtr);
++
++- VLOG2Q_NEON_F32(log2_approx, aval)
+++ VLOG2Q_NEON_F32(log2_approx, aval)
++
++- vst1q_f32(bPtr, log2_approx);
+++ vst1q_f32(bPtr, log2_approx);
++
++- aPtr += 4;
++- bPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- volk_32f_log2_32f_generic(bPtr, aPtr, num_points-number);
+++ number = quarterPoints * 4;
+++ volk_32f_log2_32f_generic(bPtr, aPtr, num_points - number);
++ }
++
++ #endif /* LV_HAVE_NEON */
++@@ -398,14 +484,14 @@ volk_32f_log2_32f_neon(float* bVector, const float* aVector, unsigned int num_po
++ static inline void
++ volk_32f_log2_32f_u_generic(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- float const result = log2f(*aPtr++);
++- *bPtr++ = isinf(result) ? -127.0f : result;
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ float const result = log2f(*aPtr++);
+++ *bPtr++ = isinf(result) ? -127.0f : result;
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -417,54 +503,79 @@ volk_32f_log2_32f_u_generic(float* bVector, const float* aVector, unsigned int n
++ #define POLY0(x, c0) _mm_set1_ps(c0)
++ #define POLY1(x, c0, c1) _mm_add_ps(_mm_mul_ps(POLY0(x, c1), x), _mm_set1_ps(c0))
++ #define POLY2(x, c0, c1, c2) _mm_add_ps(_mm_mul_ps(POLY1(x, c1, c2), x), _mm_set1_ps(c0))
++-#define POLY3(x, c0, c1, c2, c3) _mm_add_ps(_mm_mul_ps(POLY2(x, c1, c2, c3), x), _mm_set1_ps(c0))
++-#define POLY4(x, c0, c1, c2, c3, c4) _mm_add_ps(_mm_mul_ps(POLY3(x, c1, c2, c3, c4), x), _mm_set1_ps(c0))
++-#define POLY5(x, c0, c1, c2, c3, c4, c5) _mm_add_ps(_mm_mul_ps(POLY4(x, c1, c2, c3, c4, c5), x), _mm_set1_ps(c0))
+++#define POLY3(x, c0, c1, c2, c3) \
+++ _mm_add_ps(_mm_mul_ps(POLY2(x, c1, c2, c3), x), _mm_set1_ps(c0))
+++#define POLY4(x, c0, c1, c2, c3, c4) \
+++ _mm_add_ps(_mm_mul_ps(POLY3(x, c1, c2, c3, c4), x), _mm_set1_ps(c0))
+++#define POLY5(x, c0, c1, c2, c3, c4, c5) \
+++ _mm_add_ps(_mm_mul_ps(POLY4(x, c1, c2, c3, c4, c5), x), _mm_set1_ps(c0))
++
++ static inline void
++ volk_32f_log2_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
++
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- __m128 aVal, bVal, mantissa, frac, leadingOne;
++- __m128i bias, exp;
+++ __m128 aVal, bVal, mantissa, frac, leadingOne;
+++ __m128i bias, exp;
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm_loadu_ps(aPtr);
++- bias = _mm_set1_epi32(127);
++- leadingOne = _mm_set1_ps(1.0f);
++- exp = _mm_sub_epi32(_mm_srli_epi32(_mm_and_si128(_mm_castps_si128(aVal), _mm_set1_epi32(0x7f800000)), 23), bias);
++- bVal = _mm_cvtepi32_ps(exp);
+++ aVal = _mm_loadu_ps(aPtr);
+++ bias = _mm_set1_epi32(127);
+++ leadingOne = _mm_set1_ps(1.0f);
+++ exp = _mm_sub_epi32(
+++ _mm_srli_epi32(
+++ _mm_and_si128(_mm_castps_si128(aVal), _mm_set1_epi32(0x7f800000)), 23),
+++ bias);
+++ bVal = _mm_cvtepi32_ps(exp);
++
++- // Now to extract mantissa
++- frac = _mm_or_ps(leadingOne, _mm_and_ps(aVal, _mm_castsi128_ps(_mm_set1_epi32(0x7fffff))));
+++ // Now to extract mantissa
+++ frac = _mm_or_ps(leadingOne,
+++ _mm_and_ps(aVal, _mm_castsi128_ps(_mm_set1_epi32(0x7fffff))));
++
++ #if LOG_POLY_DEGREE == 6
++- mantissa = POLY5( frac, 3.1157899f, -3.3241990f, 2.5988452f, -1.2315303f, 3.1821337e-1f, -3.4436006e-2f);
+++ mantissa = POLY5(frac,
+++ 3.1157899f,
+++ -3.3241990f,
+++ 2.5988452f,
+++ -1.2315303f,
+++ 3.1821337e-1f,
+++ -3.4436006e-2f);
++ #elif LOG_POLY_DEGREE == 5
++- mantissa = POLY4( frac, 2.8882704548164776201f, -2.52074962577807006663f, 1.48116647521213171641f, -0.465725644288844778798f, 0.0596515482674574969533f);
+++ mantissa = POLY4(frac,
+++ 2.8882704548164776201f,
+++ -2.52074962577807006663f,
+++ 1.48116647521213171641f,
+++ -0.465725644288844778798f,
+++ 0.0596515482674574969533f);
++ #elif LOG_POLY_DEGREE == 4
++- mantissa = POLY3( frac, 2.61761038894603480148f, -1.75647175389045657003f, 0.688243882994381274313f, -0.107254423828329604454f);
+++ mantissa = POLY3(frac,
+++ 2.61761038894603480148f,
+++ -1.75647175389045657003f,
+++ 0.688243882994381274313f,
+++ -0.107254423828329604454f);
++ #elif LOG_POLY_DEGREE == 3
++- mantissa = POLY2( frac, 2.28330284476918490682f, -1.04913055217340124191f, 0.204446009836232697516f);
+++ mantissa = POLY2(frac,
+++ 2.28330284476918490682f,
+++ -1.04913055217340124191f,
+++ 0.204446009836232697516f);
++ #else
++ #error
++ #endif
++
++- bVal = _mm_add_ps(bVal, _mm_mul_ps(mantissa, _mm_sub_ps(frac, leadingOne)));
++- _mm_storeu_ps(bPtr, bVal);
+++ bVal = _mm_add_ps(bVal, _mm_mul_ps(mantissa, _mm_sub_ps(frac, leadingOne)));
+++ _mm_storeu_ps(bPtr, bVal);
++
++- aPtr += 4;
++- bPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- volk_32f_log2_32f_u_generic(bPtr, aPtr, num_points-number);
+++ number = quarterPoints * 4;
+++ volk_32f_log2_32f_u_generic(bPtr, aPtr, num_points - number);
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for unaligned */
++@@ -473,56 +584,86 @@ volk_32f_log2_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int nu
++ #include <immintrin.h>
++
++ #define POLY0_FMAAVX2(x, c0) _mm256_set1_ps(c0)
++-#define POLY1_FMAAVX2(x, c0, c1) _mm256_fmadd_ps(POLY0_FMAAVX2(x, c1), x, _mm256_set1_ps(c0))
++-#define POLY2_FMAAVX2(x, c0, c1, c2) _mm256_fmadd_ps(POLY1_FMAAVX2(x, c1, c2), x, _mm256_set1_ps(c0))
++-#define POLY3_FMAAVX2(x, c0, c1, c2, c3) _mm256_fmadd_ps(POLY2_FMAAVX2(x, c1, c2, c3), x, _mm256_set1_ps(c0))
++-#define POLY4_FMAAVX2(x, c0, c1, c2, c3, c4) _mm256_fmadd_ps(POLY3_FMAAVX2(x, c1, c2, c3, c4), x, _mm256_set1_ps(c0))
++-#define POLY5_FMAAVX2(x, c0, c1, c2, c3, c4, c5) _mm256_fmadd_ps(POLY4_FMAAVX2(x, c1, c2, c3, c4, c5), x, _mm256_set1_ps(c0))
++-
++-static inline void
++-volk_32f_log2_32f_u_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
+++#define POLY1_FMAAVX2(x, c0, c1) \
+++ _mm256_fmadd_ps(POLY0_FMAAVX2(x, c1), x, _mm256_set1_ps(c0))
+++#define POLY2_FMAAVX2(x, c0, c1, c2) \
+++ _mm256_fmadd_ps(POLY1_FMAAVX2(x, c1, c2), x, _mm256_set1_ps(c0))
+++#define POLY3_FMAAVX2(x, c0, c1, c2, c3) \
+++ _mm256_fmadd_ps(POLY2_FMAAVX2(x, c1, c2, c3), x, _mm256_set1_ps(c0))
+++#define POLY4_FMAAVX2(x, c0, c1, c2, c3, c4) \
+++ _mm256_fmadd_ps(POLY3_FMAAVX2(x, c1, c2, c3, c4), x, _mm256_set1_ps(c0))
+++#define POLY5_FMAAVX2(x, c0, c1, c2, c3, c4, c5) \
+++ _mm256_fmadd_ps(POLY4_FMAAVX2(x, c1, c2, c3, c4, c5), x, _mm256_set1_ps(c0))
+++
+++static inline void volk_32f_log2_32f_u_avx2_fma(float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
++
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- __m256 aVal, bVal, mantissa, frac, leadingOne;
++- __m256i bias, exp;
+++ __m256 aVal, bVal, mantissa, frac, leadingOne;
+++ __m256i bias, exp;
++
++- for(;number < eighthPoints; number++){
+++ for (; number < eighthPoints; number++) {
++
++- aVal = _mm256_loadu_ps(aPtr);
++- bias = _mm256_set1_epi32(127);
++- leadingOne = _mm256_set1_ps(1.0f);
++- exp = _mm256_sub_epi32(_mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal), _mm256_set1_epi32(0x7f800000)), 23), bias);
++- bVal = _mm256_cvtepi32_ps(exp);
+++ aVal = _mm256_loadu_ps(aPtr);
+++ bias = _mm256_set1_epi32(127);
+++ leadingOne = _mm256_set1_ps(1.0f);
+++ exp = _mm256_sub_epi32(
+++ _mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal),
+++ _mm256_set1_epi32(0x7f800000)),
+++ 23),
+++ bias);
+++ bVal = _mm256_cvtepi32_ps(exp);
++
++- // Now to extract mantissa
++- frac = _mm256_or_ps(leadingOne, _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
+++ // Now to extract mantissa
+++ frac = _mm256_or_ps(
+++ leadingOne,
+++ _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
++
++ #if LOG_POLY_DEGREE == 6
++- mantissa = POLY5_FMAAVX2( frac, 3.1157899f, -3.3241990f, 2.5988452f, -1.2315303f, 3.1821337e-1f, -3.4436006e-2f);
+++ mantissa = POLY5_FMAAVX2(frac,
+++ 3.1157899f,
+++ -3.3241990f,
+++ 2.5988452f,
+++ -1.2315303f,
+++ 3.1821337e-1f,
+++ -3.4436006e-2f);
++ #elif LOG_POLY_DEGREE == 5
++- mantissa = POLY4_FMAAVX2( frac, 2.8882704548164776201f, -2.52074962577807006663f, 1.48116647521213171641f, -0.465725644288844778798f, 0.0596515482674574969533f);
+++ mantissa = POLY4_FMAAVX2(frac,
+++ 2.8882704548164776201f,
+++ -2.52074962577807006663f,
+++ 1.48116647521213171641f,
+++ -0.465725644288844778798f,
+++ 0.0596515482674574969533f);
++ #elif LOG_POLY_DEGREE == 4
++- mantissa = POLY3_FMAAVX2( frac, 2.61761038894603480148f, -1.75647175389045657003f, 0.688243882994381274313f, -0.107254423828329604454f);
+++ mantissa = POLY3_FMAAVX2(frac,
+++ 2.61761038894603480148f,
+++ -1.75647175389045657003f,
+++ 0.688243882994381274313f,
+++ -0.107254423828329604454f);
++ #elif LOG_POLY_DEGREE == 3
++- mantissa = POLY2_FMAAVX2( frac, 2.28330284476918490682f, -1.04913055217340124191f, 0.204446009836232697516f);
+++ mantissa = POLY2_FMAAVX2(frac,
+++ 2.28330284476918490682f,
+++ -1.04913055217340124191f,
+++ 0.204446009836232697516f);
++ #else
++ #error
++ #endif
++
++- bVal = _mm256_fmadd_ps(mantissa, _mm256_sub_ps(frac, leadingOne), bVal);
++- _mm256_storeu_ps(bPtr, bVal);
+++ bVal = _mm256_fmadd_ps(mantissa, _mm256_sub_ps(frac, leadingOne), bVal);
+++ _mm256_storeu_ps(bPtr, bVal);
++
++- aPtr += 8;
++- bPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- volk_32f_log2_32f_u_generic(bPtr, aPtr, num_points-number);
+++ number = eighthPoints * 8;
+++ volk_32f_log2_32f_u_generic(bPtr, aPtr, num_points - number);
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for unaligned */
++@@ -531,56 +672,86 @@ volk_32f_log2_32f_u_avx2_fma(float* bVector, const float* aVector, unsigned int
++ #include <immintrin.h>
++
++ #define POLY0_AVX2(x, c0) _mm256_set1_ps(c0)
++-#define POLY1_AVX2(x, c0, c1) _mm256_add_ps(_mm256_mul_ps(POLY0_AVX2(x, c1), x), _mm256_set1_ps(c0))
++-#define POLY2_AVX2(x, c0, c1, c2) _mm256_add_ps(_mm256_mul_ps(POLY1_AVX2(x, c1, c2), x), _mm256_set1_ps(c0))
++-#define POLY3_AVX2(x, c0, c1, c2, c3) _mm256_add_ps(_mm256_mul_ps(POLY2_AVX2(x, c1, c2, c3), x), _mm256_set1_ps(c0))
++-#define POLY4_AVX2(x, c0, c1, c2, c3, c4) _mm256_add_ps(_mm256_mul_ps(POLY3_AVX2(x, c1, c2, c3, c4), x), _mm256_set1_ps(c0))
++-#define POLY5_AVX2(x, c0, c1, c2, c3, c4, c5) _mm256_add_ps(_mm256_mul_ps(POLY4_AVX2(x, c1, c2, c3, c4, c5), x), _mm256_set1_ps(c0))
+++#define POLY1_AVX2(x, c0, c1) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY0_AVX2(x, c1), x), _mm256_set1_ps(c0))
+++#define POLY2_AVX2(x, c0, c1, c2) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY1_AVX2(x, c1, c2), x), _mm256_set1_ps(c0))
+++#define POLY3_AVX2(x, c0, c1, c2, c3) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY2_AVX2(x, c1, c2, c3), x), _mm256_set1_ps(c0))
+++#define POLY4_AVX2(x, c0, c1, c2, c3, c4) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY3_AVX2(x, c1, c2, c3, c4), x), _mm256_set1_ps(c0))
+++#define POLY5_AVX2(x, c0, c1, c2, c3, c4, c5) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY4_AVX2(x, c1, c2, c3, c4, c5), x), _mm256_set1_ps(c0))
++
++ static inline void
++ volk_32f_log2_32f_u_avx2(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
++
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- __m256 aVal, bVal, mantissa, frac, leadingOne;
++- __m256i bias, exp;
+++ __m256 aVal, bVal, mantissa, frac, leadingOne;
+++ __m256i bias, exp;
++
++- for(;number < eighthPoints; number++){
+++ for (; number < eighthPoints; number++) {
++
++- aVal = _mm256_loadu_ps(aPtr);
++- bias = _mm256_set1_epi32(127);
++- leadingOne = _mm256_set1_ps(1.0f);
++- exp = _mm256_sub_epi32(_mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal), _mm256_set1_epi32(0x7f800000)), 23), bias);
++- bVal = _mm256_cvtepi32_ps(exp);
+++ aVal = _mm256_loadu_ps(aPtr);
+++ bias = _mm256_set1_epi32(127);
+++ leadingOne = _mm256_set1_ps(1.0f);
+++ exp = _mm256_sub_epi32(
+++ _mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal),
+++ _mm256_set1_epi32(0x7f800000)),
+++ 23),
+++ bias);
+++ bVal = _mm256_cvtepi32_ps(exp);
++
++- // Now to extract mantissa
++- frac = _mm256_or_ps(leadingOne, _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
+++ // Now to extract mantissa
+++ frac = _mm256_or_ps(
+++ leadingOne,
+++ _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
++
++ #if LOG_POLY_DEGREE == 6
++- mantissa = POLY5_AVX2( frac, 3.1157899f, -3.3241990f, 2.5988452f, -1.2315303f, 3.1821337e-1f, -3.4436006e-2f);
+++ mantissa = POLY5_AVX2(frac,
+++ 3.1157899f,
+++ -3.3241990f,
+++ 2.5988452f,
+++ -1.2315303f,
+++ 3.1821337e-1f,
+++ -3.4436006e-2f);
++ #elif LOG_POLY_DEGREE == 5
++- mantissa = POLY4_AVX2( frac, 2.8882704548164776201f, -2.52074962577807006663f, 1.48116647521213171641f, -0.465725644288844778798f, 0.0596515482674574969533f);
+++ mantissa = POLY4_AVX2(frac,
+++ 2.8882704548164776201f,
+++ -2.52074962577807006663f,
+++ 1.48116647521213171641f,
+++ -0.465725644288844778798f,
+++ 0.0596515482674574969533f);
++ #elif LOG_POLY_DEGREE == 4
++- mantissa = POLY3_AVX2( frac, 2.61761038894603480148f, -1.75647175389045657003f, 0.688243882994381274313f, -0.107254423828329604454f);
+++ mantissa = POLY3_AVX2(frac,
+++ 2.61761038894603480148f,
+++ -1.75647175389045657003f,
+++ 0.688243882994381274313f,
+++ -0.107254423828329604454f);
++ #elif LOG_POLY_DEGREE == 3
++- mantissa = POLY2_AVX2( frac, 2.28330284476918490682f, -1.04913055217340124191f, 0.204446009836232697516f);
+++ mantissa = POLY2_AVX2(frac,
+++ 2.28330284476918490682f,
+++ -1.04913055217340124191f,
+++ 0.204446009836232697516f);
++ #else
++ #error
++ #endif
++
++- bVal = _mm256_add_ps(_mm256_mul_ps(mantissa, _mm256_sub_ps(frac, leadingOne)), bVal);
++- _mm256_storeu_ps(bPtr, bVal);
+++ bVal =
+++ _mm256_add_ps(_mm256_mul_ps(mantissa, _mm256_sub_ps(frac, leadingOne)), bVal);
+++ _mm256_storeu_ps(bPtr, bVal);
++
++- aPtr += 8;
++- bPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- volk_32f_log2_32f_u_generic(bPtr, aPtr, num_points-number);
+++ number = eighthPoints * 8;
+++ volk_32f_log2_32f_u_generic(bPtr, aPtr, num_points - number);
++ }
++
++ #endif /* LV_HAVE_AVX2 for unaligned */
++diff --git a/kernels/volk/volk_32f_null_32f.h b/kernels/volk/volk_32f_null_32f.h
++index 95e8d1a..cbed229 100644
++--- a/kernels/volk/volk_32f_null_32f.h
+++++ b/kernels/volk/volk_32f_null_32f.h
++@@ -20,9 +20,9 @@
++ * Boston, MA 02110-1301, USA.
++ */
++
++-#include <stdio.h>
++-#include <math.h>
++ #include <inttypes.h>
+++#include <math.h>
+++#include <stdio.h>
++
++ #ifndef INCLUDED_volk_32f_null_32f_a_H
++ #define INCLUDED_volk_32f_null_32f_a_H
++@@ -32,13 +32,13 @@
++ static inline void
++ volk_32f_null_32f_generic(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++- unsigned int number;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++ unsigned int number;
++
++- for(number = 0; number < num_points; number++){
++- *bPtr++ = *aPtr++;
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *bPtr++ = *aPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32f_s32f_32f_fm_detect_32f.h b/kernels/volk/volk_32f_s32f_32f_fm_detect_32f.h
++index 9879959..3bf7aea 100644
++--- a/kernels/volk/volk_32f_s32f_32f_fm_detect_32f.h
+++++ b/kernels/volk/volk_32f_s32f_32f_fm_detect_32f.h
++@@ -30,14 +30,15 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_s32f_32f_fm_detect_32f(float* outputVector, const float* inputVector, const float bound, float* saveValue, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_s32f_32f_fm_detect_32f(float* outputVector, const float* inputVector,
+++ * const float bound, float* saveValue, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++- * \li inputVector: The input vector containing phase data (must be on the interval (-bound, bound]).
++- * \li bound: The interval that the input phase data is in, which is used to modulo the differentiation.
++- * \li saveValue: A pointer to a float which contains the phase value of the sample before the first input sample.
++- * \li num_points The number of data points.
+++ * \li inputVector: The input vector containing phase data (must be on the interval
+++ * (-bound, bound]). \li bound: The interval that the input phase data is in, which is
+++ * used to modulo the differentiation. \li saveValue: A pointer to a float which contains
+++ * the phase value of the sample before the first input sample. \li num_points The number
+++ * of data points.
++ *
++ * \b Outputs
++ * \li outputVector: The vector where the results will be stored.
++@@ -62,67 +63,79 @@
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32f_s32f_32f_fm_detect_32f_a_avx(float* outputVector, const float* inputVector, const float bound, float* saveValue, unsigned int num_points){
++- if (num_points < 1) {
++- return;
++- }
++- unsigned int number = 1;
++- unsigned int j = 0;
++- // num_points-1 keeps Fedora 7's gcc from crashing...
++- // num_points won't work. :(
++- const unsigned int eighthPoints = (num_points-1) / 8;
++-
++- float* outPtr = outputVector;
++- const float* inPtr = inputVector;
++- __m256 upperBound = _mm256_set1_ps(bound);
++- __m256 lowerBound = _mm256_set1_ps(-bound);
++- __m256 next3old1;
++- __m256 next4;
++- __m256 boundAdjust;
++- __m256 posBoundAdjust = _mm256_set1_ps(-2*bound); // Subtract when we're above.
++- __m256 negBoundAdjust = _mm256_set1_ps(2*bound); // Add when we're below.
++- // Do the first 8 by hand since we're going in from the saveValue:
++- *outPtr = *inPtr - *saveValue;
++- if (*outPtr > bound) *outPtr -= 2*bound;
++- if (*outPtr < -bound) *outPtr += 2*bound;
++- inPtr++;
++- outPtr++;
++- for (j = 1; j < ( (8 < num_points) ? 8 : num_points); j++) {
++- *outPtr = *(inPtr) - *(inPtr-1);
++- if (*outPtr > bound) *outPtr -= 2*bound;
++- if (*outPtr < -bound) *outPtr += 2*bound;
++- inPtr++;
++- outPtr++;
++- }
++-
++- for (; number < eighthPoints; number++) {
++- // Load data
++- next3old1 = _mm256_loadu_ps((float*) (inPtr-1));
++- next4 = _mm256_load_ps(inPtr);
++- inPtr += 8;
++- // Subtract and store:
++- next3old1 = _mm256_sub_ps(next4, next3old1);
++- // Bound:
++- boundAdjust = _mm256_cmp_ps(next3old1, upperBound, _CMP_GT_OS);
++- boundAdjust = _mm256_and_ps(boundAdjust, posBoundAdjust);
++- next4 = _mm256_cmp_ps(next3old1, lowerBound, _CMP_LT_OS);
++- next4 = _mm256_and_ps(next4, negBoundAdjust);
++- boundAdjust = _mm256_or_ps(next4, boundAdjust);
++- // Make sure we're in the bounding interval:
++- next3old1 = _mm256_add_ps(next3old1, boundAdjust);
++- _mm256_store_ps(outPtr,next3old1); // Store the results back into the output
++- outPtr += 8;
++- }
++-
++- for (number = (8 > (eighthPoints*8) ? 8 : (8 * eighthPoints)); number < num_points; number++) {
++- *outPtr = *(inPtr) - *(inPtr-1);
++- if (*outPtr > bound) *outPtr -= 2*bound;
++- if (*outPtr < -bound) *outPtr += 2*bound;
+++static inline void volk_32f_s32f_32f_fm_detect_32f_a_avx(float* outputVector,
+++ const float* inputVector,
+++ const float bound,
+++ float* saveValue,
+++ unsigned int num_points)
+++{
+++ if (num_points < 1) {
+++ return;
+++ }
+++ unsigned int number = 1;
+++ unsigned int j = 0;
+++ // num_points-1 keeps Fedora 7's gcc from crashing...
+++ // num_points won't work. :(
+++ const unsigned int eighthPoints = (num_points - 1) / 8;
+++
+++ float* outPtr = outputVector;
+++ const float* inPtr = inputVector;
+++ __m256 upperBound = _mm256_set1_ps(bound);
+++ __m256 lowerBound = _mm256_set1_ps(-bound);
+++ __m256 next3old1;
+++ __m256 next4;
+++ __m256 boundAdjust;
+++ __m256 posBoundAdjust = _mm256_set1_ps(-2 * bound); // Subtract when we're above.
+++ __m256 negBoundAdjust = _mm256_set1_ps(2 * bound); // Add when we're below.
+++ // Do the first 8 by hand since we're going in from the saveValue:
+++ *outPtr = *inPtr - *saveValue;
+++ if (*outPtr > bound)
+++ *outPtr -= 2 * bound;
+++ if (*outPtr < -bound)
+++ *outPtr += 2 * bound;
++ inPtr++;
++ outPtr++;
++- }
++-
++- *saveValue = inputVector[num_points-1];
+++ for (j = 1; j < ((8 < num_points) ? 8 : num_points); j++) {
+++ *outPtr = *(inPtr) - *(inPtr - 1);
+++ if (*outPtr > bound)
+++ *outPtr -= 2 * bound;
+++ if (*outPtr < -bound)
+++ *outPtr += 2 * bound;
+++ inPtr++;
+++ outPtr++;
+++ }
+++
+++ for (; number < eighthPoints; number++) {
+++ // Load data
+++ next3old1 = _mm256_loadu_ps((float*)(inPtr - 1));
+++ next4 = _mm256_load_ps(inPtr);
+++ inPtr += 8;
+++ // Subtract and store:
+++ next3old1 = _mm256_sub_ps(next4, next3old1);
+++ // Bound:
+++ boundAdjust = _mm256_cmp_ps(next3old1, upperBound, _CMP_GT_OS);
+++ boundAdjust = _mm256_and_ps(boundAdjust, posBoundAdjust);
+++ next4 = _mm256_cmp_ps(next3old1, lowerBound, _CMP_LT_OS);
+++ next4 = _mm256_and_ps(next4, negBoundAdjust);
+++ boundAdjust = _mm256_or_ps(next4, boundAdjust);
+++ // Make sure we're in the bounding interval:
+++ next3old1 = _mm256_add_ps(next3old1, boundAdjust);
+++ _mm256_store_ps(outPtr, next3old1); // Store the results back into the output
+++ outPtr += 8;
+++ }
+++
+++ for (number = (8 > (eighthPoints * 8) ? 8 : (8 * eighthPoints)); number < num_points;
+++ number++) {
+++ *outPtr = *(inPtr) - *(inPtr - 1);
+++ if (*outPtr > bound)
+++ *outPtr -= 2 * bound;
+++ if (*outPtr < -bound)
+++ *outPtr += 2 * bound;
+++ inPtr++;
+++ outPtr++;
+++ }
+++
+++ *saveValue = inputVector[num_points - 1];
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -130,102 +143,122 @@ static inline void volk_32f_s32f_32f_fm_detect_32f_a_avx(float* outputVector, co
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void volk_32f_s32f_32f_fm_detect_32f_a_sse(float* outputVector, const float* inputVector, const float bound, float* saveValue, unsigned int num_points){
++- if (num_points < 1) {
++- return;
++- }
++- unsigned int number = 1;
++- unsigned int j = 0;
++- // num_points-1 keeps Fedora 7's gcc from crashing...
++- // num_points won't work. :(
++- const unsigned int quarterPoints = (num_points-1) / 4;
++-
++- float* outPtr = outputVector;
++- const float* inPtr = inputVector;
++- __m128 upperBound = _mm_set_ps1(bound);
++- __m128 lowerBound = _mm_set_ps1(-bound);
++- __m128 next3old1;
++- __m128 next4;
++- __m128 boundAdjust;
++- __m128 posBoundAdjust = _mm_set_ps1(-2*bound); // Subtract when we're above.
++- __m128 negBoundAdjust = _mm_set_ps1(2*bound); // Add when we're below.
++- // Do the first 4 by hand since we're going in from the saveValue:
++- *outPtr = *inPtr - *saveValue;
++- if (*outPtr > bound) *outPtr -= 2*bound;
++- if (*outPtr < -bound) *outPtr += 2*bound;
++- inPtr++;
++- outPtr++;
++- for (j = 1; j < ( (4 < num_points) ? 4 : num_points); j++) {
++- *outPtr = *(inPtr) - *(inPtr-1);
++- if (*outPtr > bound) *outPtr -= 2*bound;
++- if (*outPtr < -bound) *outPtr += 2*bound;
++- inPtr++;
++- outPtr++;
++- }
++-
++- for (; number < quarterPoints; number++) {
++- // Load data
++- next3old1 = _mm_loadu_ps((float*) (inPtr-1));
++- next4 = _mm_load_ps(inPtr);
++- inPtr += 4;
++- // Subtract and store:
++- next3old1 = _mm_sub_ps(next4, next3old1);
++- // Bound:
++- boundAdjust = _mm_cmpgt_ps(next3old1, upperBound);
++- boundAdjust = _mm_and_ps(boundAdjust, posBoundAdjust);
++- next4 = _mm_cmplt_ps(next3old1, lowerBound);
++- next4 = _mm_and_ps(next4, negBoundAdjust);
++- boundAdjust = _mm_or_ps(next4, boundAdjust);
++- // Make sure we're in the bounding interval:
++- next3old1 = _mm_add_ps(next3old1, boundAdjust);
++- _mm_store_ps(outPtr,next3old1); // Store the results back into the output
++- outPtr += 4;
++- }
++-
++- for (number = (4 > (quarterPoints*4) ? 4 : (4 * quarterPoints)); number < num_points; number++) {
++- *outPtr = *(inPtr) - *(inPtr-1);
++- if (*outPtr > bound) *outPtr -= 2*bound;
++- if (*outPtr < -bound) *outPtr += 2*bound;
+++static inline void volk_32f_s32f_32f_fm_detect_32f_a_sse(float* outputVector,
+++ const float* inputVector,
+++ const float bound,
+++ float* saveValue,
+++ unsigned int num_points)
+++{
+++ if (num_points < 1) {
+++ return;
+++ }
+++ unsigned int number = 1;
+++ unsigned int j = 0;
+++ // num_points-1 keeps Fedora 7's gcc from crashing...
+++ // num_points won't work. :(
+++ const unsigned int quarterPoints = (num_points - 1) / 4;
+++
+++ float* outPtr = outputVector;
+++ const float* inPtr = inputVector;
+++ __m128 upperBound = _mm_set_ps1(bound);
+++ __m128 lowerBound = _mm_set_ps1(-bound);
+++ __m128 next3old1;
+++ __m128 next4;
+++ __m128 boundAdjust;
+++ __m128 posBoundAdjust = _mm_set_ps1(-2 * bound); // Subtract when we're above.
+++ __m128 negBoundAdjust = _mm_set_ps1(2 * bound); // Add when we're below.
+++ // Do the first 4 by hand since we're going in from the saveValue:
+++ *outPtr = *inPtr - *saveValue;
+++ if (*outPtr > bound)
+++ *outPtr -= 2 * bound;
+++ if (*outPtr < -bound)
+++ *outPtr += 2 * bound;
++ inPtr++;
++ outPtr++;
++- }
++-
++- *saveValue = inputVector[num_points-1];
+++ for (j = 1; j < ((4 < num_points) ? 4 : num_points); j++) {
+++ *outPtr = *(inPtr) - *(inPtr - 1);
+++ if (*outPtr > bound)
+++ *outPtr -= 2 * bound;
+++ if (*outPtr < -bound)
+++ *outPtr += 2 * bound;
+++ inPtr++;
+++ outPtr++;
+++ }
+++
+++ for (; number < quarterPoints; number++) {
+++ // Load data
+++ next3old1 = _mm_loadu_ps((float*)(inPtr - 1));
+++ next4 = _mm_load_ps(inPtr);
+++ inPtr += 4;
+++ // Subtract and store:
+++ next3old1 = _mm_sub_ps(next4, next3old1);
+++ // Bound:
+++ boundAdjust = _mm_cmpgt_ps(next3old1, upperBound);
+++ boundAdjust = _mm_and_ps(boundAdjust, posBoundAdjust);
+++ next4 = _mm_cmplt_ps(next3old1, lowerBound);
+++ next4 = _mm_and_ps(next4, negBoundAdjust);
+++ boundAdjust = _mm_or_ps(next4, boundAdjust);
+++ // Make sure we're in the bounding interval:
+++ next3old1 = _mm_add_ps(next3old1, boundAdjust);
+++ _mm_store_ps(outPtr, next3old1); // Store the results back into the output
+++ outPtr += 4;
+++ }
+++
+++ for (number = (4 > (quarterPoints * 4) ? 4 : (4 * quarterPoints));
+++ number < num_points;
+++ number++) {
+++ *outPtr = *(inPtr) - *(inPtr - 1);
+++ if (*outPtr > bound)
+++ *outPtr -= 2 * bound;
+++ if (*outPtr < -bound)
+++ *outPtr += 2 * bound;
+++ inPtr++;
+++ outPtr++;
+++ }
+++
+++ *saveValue = inputVector[num_points - 1];
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32f_s32f_32f_fm_detect_32f_generic(float* outputVector, const float* inputVector, const float bound, float* saveValue, unsigned int num_points){
++- if (num_points < 1) {
++- return;
++- }
++- unsigned int number = 0;
++- float* outPtr = outputVector;
++- const float* inPtr = inputVector;
++-
++- // Do the first 1 by hand since we're going in from the saveValue:
++- *outPtr = *inPtr - *saveValue;
++- if (*outPtr > bound) *outPtr -= 2*bound;
++- if (*outPtr < -bound) *outPtr += 2*bound;
++- inPtr++;
++- outPtr++;
++-
++- for (number = 1; number < num_points; number++) {
++- *outPtr = *(inPtr) - *(inPtr-1);
++- if (*outPtr > bound) *outPtr -= 2*bound;
++- if (*outPtr < -bound) *outPtr += 2*bound;
+++static inline void volk_32f_s32f_32f_fm_detect_32f_generic(float* outputVector,
+++ const float* inputVector,
+++ const float bound,
+++ float* saveValue,
+++ unsigned int num_points)
+++{
+++ if (num_points < 1) {
+++ return;
+++ }
+++ unsigned int number = 0;
+++ float* outPtr = outputVector;
+++ const float* inPtr = inputVector;
+++
+++ // Do the first 1 by hand since we're going in from the saveValue:
+++ *outPtr = *inPtr - *saveValue;
+++ if (*outPtr > bound)
+++ *outPtr -= 2 * bound;
+++ if (*outPtr < -bound)
+++ *outPtr += 2 * bound;
++ inPtr++;
++ outPtr++;
++- }
++
++- *saveValue = inputVector[num_points-1];
+++ for (number = 1; number < num_points; number++) {
+++ *outPtr = *(inPtr) - *(inPtr - 1);
+++ if (*outPtr > bound)
+++ *outPtr -= 2 * bound;
+++ if (*outPtr < -bound)
+++ *outPtr += 2 * bound;
+++ inPtr++;
+++ outPtr++;
+++ }
+++
+++ *saveValue = inputVector[num_points - 1];
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++-
++ #endif /* INCLUDED_volk_32f_s32f_32f_fm_detect_32f_a_H */
++
++
++@@ -238,67 +271,79 @@ static inline void volk_32f_s32f_32f_fm_detect_32f_generic(float* outputVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32f_s32f_32f_fm_detect_32f_u_avx(float* outputVector, const float* inputVector, const float bound, float* saveValue, unsigned int num_points){
++- if (num_points < 1) {
++- return;
++- }
++- unsigned int number = 1;
++- unsigned int j = 0;
++- // num_points-1 keeps Fedora 7's gcc from crashing...
++- // num_points won't work. :(
++- const unsigned int eighthPoints = (num_points-1) / 8;
++-
++- float* outPtr = outputVector;
++- const float* inPtr = inputVector;
++- __m256 upperBound = _mm256_set1_ps(bound);
++- __m256 lowerBound = _mm256_set1_ps(-bound);
++- __m256 next3old1;
++- __m256 next4;
++- __m256 boundAdjust;
++- __m256 posBoundAdjust = _mm256_set1_ps(-2*bound); // Subtract when we're above.
++- __m256 negBoundAdjust = _mm256_set1_ps(2*bound); // Add when we're below.
++- // Do the first 8 by hand since we're going in from the saveValue:
++- *outPtr = *inPtr - *saveValue;
++- if (*outPtr > bound) *outPtr -= 2*bound;
++- if (*outPtr < -bound) *outPtr += 2*bound;
++- inPtr++;
++- outPtr++;
++- for (j = 1; j < ( (8 < num_points) ? 8 : num_points); j++) {
++- *outPtr = *(inPtr) - *(inPtr-1);
++- if (*outPtr > bound) *outPtr -= 2*bound;
++- if (*outPtr < -bound) *outPtr += 2*bound;
+++static inline void volk_32f_s32f_32f_fm_detect_32f_u_avx(float* outputVector,
+++ const float* inputVector,
+++ const float bound,
+++ float* saveValue,
+++ unsigned int num_points)
+++{
+++ if (num_points < 1) {
+++ return;
+++ }
+++ unsigned int number = 1;
+++ unsigned int j = 0;
+++ // num_points-1 keeps Fedora 7's gcc from crashing...
+++ // num_points won't work. :(
+++ const unsigned int eighthPoints = (num_points - 1) / 8;
+++
+++ float* outPtr = outputVector;
+++ const float* inPtr = inputVector;
+++ __m256 upperBound = _mm256_set1_ps(bound);
+++ __m256 lowerBound = _mm256_set1_ps(-bound);
+++ __m256 next3old1;
+++ __m256 next4;
+++ __m256 boundAdjust;
+++ __m256 posBoundAdjust = _mm256_set1_ps(-2 * bound); // Subtract when we're above.
+++ __m256 negBoundAdjust = _mm256_set1_ps(2 * bound); // Add when we're below.
+++ // Do the first 8 by hand since we're going in from the saveValue:
+++ *outPtr = *inPtr - *saveValue;
+++ if (*outPtr > bound)
+++ *outPtr -= 2 * bound;
+++ if (*outPtr < -bound)
+++ *outPtr += 2 * bound;
++ inPtr++;
++ outPtr++;
++- }
++-
++- for (; number < eighthPoints; number++) {
++- // Load data
++- next3old1 = _mm256_loadu_ps((float*) (inPtr-1));
++- next4 = _mm256_loadu_ps(inPtr);
++- inPtr += 8;
++- // Subtract and store:
++- next3old1 = _mm256_sub_ps(next4, next3old1);
++- // Bound:
++- boundAdjust = _mm256_cmp_ps(next3old1, upperBound, _CMP_GT_OS);
++- boundAdjust = _mm256_and_ps(boundAdjust, posBoundAdjust);
++- next4 = _mm256_cmp_ps(next3old1, lowerBound, _CMP_LT_OS);
++- next4 = _mm256_and_ps(next4, negBoundAdjust);
++- boundAdjust = _mm256_or_ps(next4, boundAdjust);
++- // Make sure we're in the bounding interval:
++- next3old1 = _mm256_add_ps(next3old1, boundAdjust);
++- _mm256_storeu_ps(outPtr,next3old1); // Store the results back into the output
++- outPtr += 8;
++- }
++-
++- for (number = (8 > (eighthPoints*8) ? 8 : (8 * eighthPoints)); number < num_points; number++) {
++- *outPtr = *(inPtr) - *(inPtr-1);
++- if (*outPtr > bound) *outPtr -= 2*bound;
++- if (*outPtr < -bound) *outPtr += 2*bound;
++- inPtr++;
++- outPtr++;
++- }
++-
++- *saveValue = inputVector[num_points-1];
+++ for (j = 1; j < ((8 < num_points) ? 8 : num_points); j++) {
+++ *outPtr = *(inPtr) - *(inPtr - 1);
+++ if (*outPtr > bound)
+++ *outPtr -= 2 * bound;
+++ if (*outPtr < -bound)
+++ *outPtr += 2 * bound;
+++ inPtr++;
+++ outPtr++;
+++ }
+++
+++ for (; number < eighthPoints; number++) {
+++ // Load data
+++ next3old1 = _mm256_loadu_ps((float*)(inPtr - 1));
+++ next4 = _mm256_loadu_ps(inPtr);
+++ inPtr += 8;
+++ // Subtract and store:
+++ next3old1 = _mm256_sub_ps(next4, next3old1);
+++ // Bound:
+++ boundAdjust = _mm256_cmp_ps(next3old1, upperBound, _CMP_GT_OS);
+++ boundAdjust = _mm256_and_ps(boundAdjust, posBoundAdjust);
+++ next4 = _mm256_cmp_ps(next3old1, lowerBound, _CMP_LT_OS);
+++ next4 = _mm256_and_ps(next4, negBoundAdjust);
+++ boundAdjust = _mm256_or_ps(next4, boundAdjust);
+++ // Make sure we're in the bounding interval:
+++ next3old1 = _mm256_add_ps(next3old1, boundAdjust);
+++ _mm256_storeu_ps(outPtr, next3old1); // Store the results back into the output
+++ outPtr += 8;
+++ }
+++
+++ for (number = (8 > (eighthPoints * 8) ? 8 : (8 * eighthPoints)); number < num_points;
+++ number++) {
+++ *outPtr = *(inPtr) - *(inPtr - 1);
+++ if (*outPtr > bound)
+++ *outPtr -= 2 * bound;
+++ if (*outPtr < -bound)
+++ *outPtr += 2 * bound;
+++ inPtr++;
+++ outPtr++;
+++ }
+++
+++ *saveValue = inputVector[num_points - 1];
++ }
++ #endif /* LV_HAVE_AVX */
++
++diff --git a/kernels/volk/volk_32f_s32f_calc_spectral_noise_floor_32f.h b/kernels/volk/volk_32f_s32f_calc_spectral_noise_floor_32f.h
++index ae371a2..e7e581f 100644
++--- a/kernels/volk/volk_32f_s32f_calc_spectral_noise_floor_32f.h
+++++ b/kernels/volk/volk_32f_s32f_calc_spectral_noise_floor_32f.h
++@@ -35,13 +35,15 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_s32f_calc_spectral_noise_floor_32f(float* noiseFloorAmplitude, const float* realDataPoints, const float spectralExclusionValue, const unsigned int num_points)
++- * \endcode
+++ * void volk_32f_s32f_calc_spectral_noise_floor_32f(float* noiseFloorAmplitude, const
+++ * float* realDataPoints, const float spectralExclusionValue, const unsigned int
+++ * num_points) \endcode
++ *
++ * \b Inputs
++ * \li realDataPoints: The input power spectrum.
++- * \li spectralExclusionValue: The number of dB above the noise floor that a data point must be to be excluded from the noise floor calculation - default value is 20.
++- * \li num_points: The number of data points.
+++ * \li spectralExclusionValue: The number of dB above the noise floor that a data point
+++ * must be to be excluded from the noise floor calculation - default value is 20. \li
+++ * num_points: The number of data points.
++ *
++ * \b Outputs
++ * \li noiseFloorAmplitude: The noise floor of the input spectrum, in dB.
++@@ -59,9 +61,9 @@
++ #ifndef INCLUDED_volk_32f_s32f_calc_spectral_noise_floor_32f_a_H
++ #define INCLUDED_volk_32f_s32f_calc_spectral_noise_floor_32f_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++@@ -72,114 +74,117 @@ volk_32f_s32f_calc_spectral_noise_floor_32f_a_avx(float* noiseFloorAmplitude,
++ const float spectralExclusionValue,
++ const unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* dataPointsPtr = realDataPoints;
++- __VOLK_ATTR_ALIGNED(32) float avgPointsVector[8];
++-
++- __m256 dataPointsVal;
++- __m256 avgPointsVal = _mm256_setzero_ps();
++- // Calculate the sum (for mean) for all points
++- for(; number < eighthPoints; number++){
++-
++- dataPointsVal = _mm256_load_ps(dataPointsPtr);
++-
++- dataPointsPtr += 8;
++-
++- avgPointsVal = _mm256_add_ps(avgPointsVal, dataPointsVal);
++- }
++-
++- _mm256_store_ps(avgPointsVector, avgPointsVal);
++-
++- float sumMean = 0.0;
++- sumMean += avgPointsVector[0];
++- sumMean += avgPointsVector[1];
++- sumMean += avgPointsVector[2];
++- sumMean += avgPointsVector[3];
++- sumMean += avgPointsVector[4];
++- sumMean += avgPointsVector[5];
++- sumMean += avgPointsVector[6];
++- sumMean += avgPointsVector[7];
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- sumMean += realDataPoints[number];
++- }
++-
++- // calculate the spectral mean
++- // +20 because for the comparison below we only want to throw out bins
++- // that are significantly higher (and would, thus, affect the mean more
++- const float meanAmplitude = (sumMean / ((float)num_points)) + spectralExclusionValue;
++-
++- dataPointsPtr = realDataPoints; // Reset the dataPointsPtr
++- __m256 vMeanAmplitudeVector = _mm256_set1_ps(meanAmplitude);
++- __m256 vOnesVector = _mm256_set1_ps(1.0);
++- __m256 vValidBinCount = _mm256_setzero_ps();
++- avgPointsVal = _mm256_setzero_ps();
++- __m256 compareMask;
++- number = 0;
++- // Calculate the sum (for mean) for any points which do NOT exceed the mean amplitude
++- for(; number < eighthPoints; number++){
++-
++- dataPointsVal = _mm256_load_ps(dataPointsPtr);
++-
++- dataPointsPtr += 8;
++-
++- // Identify which items do not exceed the mean amplitude
++- compareMask = _mm256_cmp_ps(dataPointsVal, vMeanAmplitudeVector, _CMP_LE_OQ);
++-
++- // Mask off the items that exceed the mean amplitude and add the avg Points that do not exceed the mean amplitude
++- avgPointsVal = _mm256_add_ps(avgPointsVal, _mm256_and_ps(compareMask, dataPointsVal));
++-
++- // Count the number of bins which do not exceed the mean amplitude
++- vValidBinCount = _mm256_add_ps(vValidBinCount, _mm256_and_ps(compareMask, vOnesVector));
++- }
++-
++- // Calculate the mean from the remaining data points
++- _mm256_store_ps(avgPointsVector, avgPointsVal);
++-
++- sumMean = 0.0;
++- sumMean += avgPointsVector[0];
++- sumMean += avgPointsVector[1];
++- sumMean += avgPointsVector[2];
++- sumMean += avgPointsVector[3];
++- sumMean += avgPointsVector[4];
++- sumMean += avgPointsVector[5];
++- sumMean += avgPointsVector[6];
++- sumMean += avgPointsVector[7];
++-
++- // Calculate the number of valid bins from the remaining count
++- __VOLK_ATTR_ALIGNED(32) float validBinCountVector[8];
++- _mm256_store_ps(validBinCountVector, vValidBinCount);
++-
++- float validBinCount = 0;
++- validBinCount += validBinCountVector[0];
++- validBinCount += validBinCountVector[1];
++- validBinCount += validBinCountVector[2];
++- validBinCount += validBinCountVector[3];
++- validBinCount += validBinCountVector[4];
++- validBinCount += validBinCountVector[5];
++- validBinCount += validBinCountVector[6];
++- validBinCount += validBinCountVector[7];
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- if(realDataPoints[number] <= meanAmplitude){
++- sumMean += realDataPoints[number];
++- validBinCount += 1.0;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const float* dataPointsPtr = realDataPoints;
+++ __VOLK_ATTR_ALIGNED(32) float avgPointsVector[8];
+++
+++ __m256 dataPointsVal;
+++ __m256 avgPointsVal = _mm256_setzero_ps();
+++ // Calculate the sum (for mean) for all points
+++ for (; number < eighthPoints; number++) {
+++
+++ dataPointsVal = _mm256_load_ps(dataPointsPtr);
+++
+++ dataPointsPtr += 8;
+++
+++ avgPointsVal = _mm256_add_ps(avgPointsVal, dataPointsVal);
++ }
++- }
++
++- float localNoiseFloorAmplitude = 0;
++- if(validBinCount > 0.0){
++- localNoiseFloorAmplitude = sumMean / validBinCount;
++- }
++- else{
++- localNoiseFloorAmplitude = meanAmplitude; // For the odd case that all the amplitudes are equal...
++- }
+++ _mm256_store_ps(avgPointsVector, avgPointsVal);
+++
+++ float sumMean = 0.0;
+++ sumMean += avgPointsVector[0];
+++ sumMean += avgPointsVector[1];
+++ sumMean += avgPointsVector[2];
+++ sumMean += avgPointsVector[3];
+++ sumMean += avgPointsVector[4];
+++ sumMean += avgPointsVector[5];
+++ sumMean += avgPointsVector[6];
+++ sumMean += avgPointsVector[7];
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ sumMean += realDataPoints[number];
+++ }
+++
+++ // calculate the spectral mean
+++ // +20 because for the comparison below we only want to throw out bins
+++ // that are significantly higher (and would, thus, affect the mean more
+++ const float meanAmplitude = (sumMean / ((float)num_points)) + spectralExclusionValue;
+++
+++ dataPointsPtr = realDataPoints; // Reset the dataPointsPtr
+++ __m256 vMeanAmplitudeVector = _mm256_set1_ps(meanAmplitude);
+++ __m256 vOnesVector = _mm256_set1_ps(1.0);
+++ __m256 vValidBinCount = _mm256_setzero_ps();
+++ avgPointsVal = _mm256_setzero_ps();
+++ __m256 compareMask;
+++ number = 0;
+++ // Calculate the sum (for mean) for any points which do NOT exceed the mean amplitude
+++ for (; number < eighthPoints; number++) {
+++
+++ dataPointsVal = _mm256_load_ps(dataPointsPtr);
+++
+++ dataPointsPtr += 8;
+++
+++ // Identify which items do not exceed the mean amplitude
+++ compareMask = _mm256_cmp_ps(dataPointsVal, vMeanAmplitudeVector, _CMP_LE_OQ);
+++
+++ // Mask off the items that exceed the mean amplitude and add the avg Points that
+++ // do not exceed the mean amplitude
+++ avgPointsVal =
+++ _mm256_add_ps(avgPointsVal, _mm256_and_ps(compareMask, dataPointsVal));
+++
+++ // Count the number of bins which do not exceed the mean amplitude
+++ vValidBinCount =
+++ _mm256_add_ps(vValidBinCount, _mm256_and_ps(compareMask, vOnesVector));
+++ }
++
++- *noiseFloorAmplitude = localNoiseFloorAmplitude;
+++ // Calculate the mean from the remaining data points
+++ _mm256_store_ps(avgPointsVector, avgPointsVal);
+++
+++ sumMean = 0.0;
+++ sumMean += avgPointsVector[0];
+++ sumMean += avgPointsVector[1];
+++ sumMean += avgPointsVector[2];
+++ sumMean += avgPointsVector[3];
+++ sumMean += avgPointsVector[4];
+++ sumMean += avgPointsVector[5];
+++ sumMean += avgPointsVector[6];
+++ sumMean += avgPointsVector[7];
+++
+++ // Calculate the number of valid bins from the remaining count
+++ __VOLK_ATTR_ALIGNED(32) float validBinCountVector[8];
+++ _mm256_store_ps(validBinCountVector, vValidBinCount);
+++
+++ float validBinCount = 0;
+++ validBinCount += validBinCountVector[0];
+++ validBinCount += validBinCountVector[1];
+++ validBinCount += validBinCountVector[2];
+++ validBinCount += validBinCountVector[3];
+++ validBinCount += validBinCountVector[4];
+++ validBinCount += validBinCountVector[5];
+++ validBinCount += validBinCountVector[6];
+++ validBinCount += validBinCountVector[7];
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ if (realDataPoints[number] <= meanAmplitude) {
+++ sumMean += realDataPoints[number];
+++ validBinCount += 1.0;
+++ }
+++ }
+++
+++ float localNoiseFloorAmplitude = 0;
+++ if (validBinCount > 0.0) {
+++ localNoiseFloorAmplitude = sumMean / validBinCount;
+++ } else {
+++ localNoiseFloorAmplitude =
+++ meanAmplitude; // For the odd case that all the amplitudes are equal...
+++ }
+++
+++ *noiseFloorAmplitude = localNoiseFloorAmplitude;
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -192,102 +197,103 @@ volk_32f_s32f_calc_spectral_noise_floor_32f_a_sse(float* noiseFloorAmplitude,
++ const float spectralExclusionValue,
++ const unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* dataPointsPtr = realDataPoints;
++- __VOLK_ATTR_ALIGNED(16) float avgPointsVector[4];
++-
++- __m128 dataPointsVal;
++- __m128 avgPointsVal = _mm_setzero_ps();
++- // Calculate the sum (for mean) for all points
++- for(; number < quarterPoints; number++){
++-
++- dataPointsVal = _mm_load_ps(dataPointsPtr);
++-
++- dataPointsPtr += 4;
++-
++- avgPointsVal = _mm_add_ps(avgPointsVal, dataPointsVal);
++- }
++-
++- _mm_store_ps(avgPointsVector, avgPointsVal);
++-
++- float sumMean = 0.0;
++- sumMean += avgPointsVector[0];
++- sumMean += avgPointsVector[1];
++- sumMean += avgPointsVector[2];
++- sumMean += avgPointsVector[3];
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- sumMean += realDataPoints[number];
++- }
++-
++- // calculate the spectral mean
++- // +20 because for the comparison below we only want to throw out bins
++- // that are significantly higher (and would, thus, affect the mean more
++- const float meanAmplitude = (sumMean / ((float)num_points)) + spectralExclusionValue;
++-
++- dataPointsPtr = realDataPoints; // Reset the dataPointsPtr
++- __m128 vMeanAmplitudeVector = _mm_set_ps1(meanAmplitude);
++- __m128 vOnesVector = _mm_set_ps1(1.0);
++- __m128 vValidBinCount = _mm_setzero_ps();
++- avgPointsVal = _mm_setzero_ps();
++- __m128 compareMask;
++- number = 0;
++- // Calculate the sum (for mean) for any points which do NOT exceed the mean amplitude
++- for(; number < quarterPoints; number++){
++-
++- dataPointsVal = _mm_load_ps(dataPointsPtr);
++-
++- dataPointsPtr += 4;
++-
++- // Identify which items do not exceed the mean amplitude
++- compareMask = _mm_cmple_ps(dataPointsVal, vMeanAmplitudeVector);
++-
++- // Mask off the items that exceed the mean amplitude and add the avg Points that do not exceed the mean amplitude
++- avgPointsVal = _mm_add_ps(avgPointsVal, _mm_and_ps(compareMask, dataPointsVal));
++-
++- // Count the number of bins which do not exceed the mean amplitude
++- vValidBinCount = _mm_add_ps(vValidBinCount, _mm_and_ps(compareMask, vOnesVector));
++- }
++-
++- // Calculate the mean from the remaining data points
++- _mm_store_ps(avgPointsVector, avgPointsVal);
++-
++- sumMean = 0.0;
++- sumMean += avgPointsVector[0];
++- sumMean += avgPointsVector[1];
++- sumMean += avgPointsVector[2];
++- sumMean += avgPointsVector[3];
++-
++- // Calculate the number of valid bins from the remaining count
++- __VOLK_ATTR_ALIGNED(16) float validBinCountVector[4];
++- _mm_store_ps(validBinCountVector, vValidBinCount);
++-
++- float validBinCount = 0;
++- validBinCount += validBinCountVector[0];
++- validBinCount += validBinCountVector[1];
++- validBinCount += validBinCountVector[2];
++- validBinCount += validBinCountVector[3];
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- if(realDataPoints[number] <= meanAmplitude){
++- sumMean += realDataPoints[number];
++- validBinCount += 1.0;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* dataPointsPtr = realDataPoints;
+++ __VOLK_ATTR_ALIGNED(16) float avgPointsVector[4];
+++
+++ __m128 dataPointsVal;
+++ __m128 avgPointsVal = _mm_setzero_ps();
+++ // Calculate the sum (for mean) for all points
+++ for (; number < quarterPoints; number++) {
+++
+++ dataPointsVal = _mm_load_ps(dataPointsPtr);
+++
+++ dataPointsPtr += 4;
+++
+++ avgPointsVal = _mm_add_ps(avgPointsVal, dataPointsVal);
+++ }
+++
+++ _mm_store_ps(avgPointsVector, avgPointsVal);
+++
+++ float sumMean = 0.0;
+++ sumMean += avgPointsVector[0];
+++ sumMean += avgPointsVector[1];
+++ sumMean += avgPointsVector[2];
+++ sumMean += avgPointsVector[3];
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ sumMean += realDataPoints[number];
+++ }
+++
+++ // calculate the spectral mean
+++ // +20 because for the comparison below we only want to throw out bins
+++ // that are significantly higher (and would, thus, affect the mean more
+++ const float meanAmplitude = (sumMean / ((float)num_points)) + spectralExclusionValue;
+++
+++ dataPointsPtr = realDataPoints; // Reset the dataPointsPtr
+++ __m128 vMeanAmplitudeVector = _mm_set_ps1(meanAmplitude);
+++ __m128 vOnesVector = _mm_set_ps1(1.0);
+++ __m128 vValidBinCount = _mm_setzero_ps();
+++ avgPointsVal = _mm_setzero_ps();
+++ __m128 compareMask;
+++ number = 0;
+++ // Calculate the sum (for mean) for any points which do NOT exceed the mean amplitude
+++ for (; number < quarterPoints; number++) {
+++
+++ dataPointsVal = _mm_load_ps(dataPointsPtr);
+++
+++ dataPointsPtr += 4;
+++
+++ // Identify which items do not exceed the mean amplitude
+++ compareMask = _mm_cmple_ps(dataPointsVal, vMeanAmplitudeVector);
+++
+++ // Mask off the items that exceed the mean amplitude and add the avg Points that
+++ // do not exceed the mean amplitude
+++ avgPointsVal = _mm_add_ps(avgPointsVal, _mm_and_ps(compareMask, dataPointsVal));
+++
+++ // Count the number of bins which do not exceed the mean amplitude
+++ vValidBinCount = _mm_add_ps(vValidBinCount, _mm_and_ps(compareMask, vOnesVector));
++ }
++- }
++
++- float localNoiseFloorAmplitude = 0;
++- if(validBinCount > 0.0){
++- localNoiseFloorAmplitude = sumMean / validBinCount;
++- }
++- else{
++- localNoiseFloorAmplitude = meanAmplitude; // For the odd case that all the amplitudes are equal...
++- }
+++ // Calculate the mean from the remaining data points
+++ _mm_store_ps(avgPointsVector, avgPointsVal);
+++
+++ sumMean = 0.0;
+++ sumMean += avgPointsVector[0];
+++ sumMean += avgPointsVector[1];
+++ sumMean += avgPointsVector[2];
+++ sumMean += avgPointsVector[3];
+++
+++ // Calculate the number of valid bins from the remaining count
+++ __VOLK_ATTR_ALIGNED(16) float validBinCountVector[4];
+++ _mm_store_ps(validBinCountVector, vValidBinCount);
+++
+++ float validBinCount = 0;
+++ validBinCount += validBinCountVector[0];
+++ validBinCount += validBinCountVector[1];
+++ validBinCount += validBinCountVector[2];
+++ validBinCount += validBinCountVector[3];
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ if (realDataPoints[number] <= meanAmplitude) {
+++ sumMean += realDataPoints[number];
+++ validBinCount += 1.0;
+++ }
+++ }
+++
+++ float localNoiseFloorAmplitude = 0;
+++ if (validBinCount > 0.0) {
+++ localNoiseFloorAmplitude = sumMean / validBinCount;
+++ } else {
+++ localNoiseFloorAmplitude =
+++ meanAmplitude; // For the odd case that all the amplitudes are equal...
+++ }
++
++- *noiseFloorAmplitude = localNoiseFloorAmplitude;
+++ *noiseFloorAmplitude = localNoiseFloorAmplitude;
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -300,36 +306,36 @@ volk_32f_s32f_calc_spectral_noise_floor_32f_generic(float* noiseFloorAmplitude,
++ const float spectralExclusionValue,
++ const unsigned int num_points)
++ {
++- float sumMean = 0.0;
++- unsigned int number;
++- // find the sum (for mean), etc
++- for(number = 0; number < num_points; number++){
++- // sum (for mean)
++- sumMean += realDataPoints[number];
++- }
++-
++- // calculate the spectral mean
++- // +20 because for the comparison below we only want to throw out bins
++- // that are significantly higher (and would, thus, affect the mean more)
++- const float meanAmplitude = (sumMean / num_points) + spectralExclusionValue;
++-
++- // now throw out any bins higher than the mean
++- sumMean = 0.0;
++- unsigned int newNumDataPoints = num_points;
++- for(number = 0; number < num_points; number++){
++- if (realDataPoints[number] <= meanAmplitude)
++- sumMean += realDataPoints[number];
++- else
++- newNumDataPoints--;
++- }
+++ float sumMean = 0.0;
+++ unsigned int number;
+++ // find the sum (for mean), etc
+++ for (number = 0; number < num_points; number++) {
+++ // sum (for mean)
+++ sumMean += realDataPoints[number];
+++ }
+++
+++ // calculate the spectral mean
+++ // +20 because for the comparison below we only want to throw out bins
+++ // that are significantly higher (and would, thus, affect the mean more)
+++ const float meanAmplitude = (sumMean / num_points) + spectralExclusionValue;
+++
+++ // now throw out any bins higher than the mean
+++ sumMean = 0.0;
+++ unsigned int newNumDataPoints = num_points;
+++ for (number = 0; number < num_points; number++) {
+++ if (realDataPoints[number] <= meanAmplitude)
+++ sumMean += realDataPoints[number];
+++ else
+++ newNumDataPoints--;
+++ }
++
++- float localNoiseFloorAmplitude = 0.0;
++- if (newNumDataPoints == 0) // in the odd case that all
++- localNoiseFloorAmplitude = meanAmplitude; // amplitudes are equal!
++- else
++- localNoiseFloorAmplitude = sumMean / ((float)newNumDataPoints);
+++ float localNoiseFloorAmplitude = 0.0;
+++ if (newNumDataPoints == 0) // in the odd case that all
+++ localNoiseFloorAmplitude = meanAmplitude; // amplitudes are equal!
+++ else
+++ localNoiseFloorAmplitude = sumMean / ((float)newNumDataPoints);
++
++- *noiseFloorAmplitude = localNoiseFloorAmplitude;
+++ *noiseFloorAmplitude = localNoiseFloorAmplitude;
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -339,9 +345,9 @@ volk_32f_s32f_calc_spectral_noise_floor_32f_generic(float* noiseFloorAmplitude,
++ #ifndef INCLUDED_volk_32f_s32f_calc_spectral_noise_floor_32f_u_H
++ #define INCLUDED_volk_32f_s32f_calc_spectral_noise_floor_32f_u_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++@@ -352,114 +358,117 @@ volk_32f_s32f_calc_spectral_noise_floor_32f_u_avx(float* noiseFloorAmplitude,
++ const float spectralExclusionValue,
++ const unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* dataPointsPtr = realDataPoints;
++- __VOLK_ATTR_ALIGNED(16) float avgPointsVector[8];
++-
++- __m256 dataPointsVal;
++- __m256 avgPointsVal = _mm256_setzero_ps();
++- // Calculate the sum (for mean) for all points
++- for(; number < eighthPoints; number++){
++-
++- dataPointsVal = _mm256_loadu_ps(dataPointsPtr);
++-
++- dataPointsPtr += 8;
++-
++- avgPointsVal = _mm256_add_ps(avgPointsVal, dataPointsVal);
++- }
++-
++- _mm256_storeu_ps(avgPointsVector, avgPointsVal);
++-
++- float sumMean = 0.0;
++- sumMean += avgPointsVector[0];
++- sumMean += avgPointsVector[1];
++- sumMean += avgPointsVector[2];
++- sumMean += avgPointsVector[3];
++- sumMean += avgPointsVector[4];
++- sumMean += avgPointsVector[5];
++- sumMean += avgPointsVector[6];
++- sumMean += avgPointsVector[7];
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- sumMean += realDataPoints[number];
++- }
++-
++- // calculate the spectral mean
++- // +20 because for the comparison below we only want to throw out bins
++- // that are significantly higher (and would, thus, affect the mean more
++- const float meanAmplitude = (sumMean / ((float)num_points)) + spectralExclusionValue;
++-
++- dataPointsPtr = realDataPoints; // Reset the dataPointsPtr
++- __m256 vMeanAmplitudeVector = _mm256_set1_ps(meanAmplitude);
++- __m256 vOnesVector = _mm256_set1_ps(1.0);
++- __m256 vValidBinCount = _mm256_setzero_ps();
++- avgPointsVal = _mm256_setzero_ps();
++- __m256 compareMask;
++- number = 0;
++- // Calculate the sum (for mean) for any points which do NOT exceed the mean amplitude
++- for(; number < eighthPoints; number++){
++-
++- dataPointsVal = _mm256_loadu_ps(dataPointsPtr);
++-
++- dataPointsPtr += 8;
++-
++- // Identify which items do not exceed the mean amplitude
++- compareMask = _mm256_cmp_ps(dataPointsVal, vMeanAmplitudeVector, _CMP_LE_OQ);
++-
++- // Mask off the items that exceed the mean amplitude and add the avg Points that do not exceed the mean amplitude
++- avgPointsVal = _mm256_add_ps(avgPointsVal, _mm256_and_ps(compareMask, dataPointsVal));
++-
++- // Count the number of bins which do not exceed the mean amplitude
++- vValidBinCount = _mm256_add_ps(vValidBinCount, _mm256_and_ps(compareMask, vOnesVector));
++- }
++-
++- // Calculate the mean from the remaining data points
++- _mm256_storeu_ps(avgPointsVector, avgPointsVal);
++-
++- sumMean = 0.0;
++- sumMean += avgPointsVector[0];
++- sumMean += avgPointsVector[1];
++- sumMean += avgPointsVector[2];
++- sumMean += avgPointsVector[3];
++- sumMean += avgPointsVector[4];
++- sumMean += avgPointsVector[5];
++- sumMean += avgPointsVector[6];
++- sumMean += avgPointsVector[7];
++-
++- // Calculate the number of valid bins from the remaining count
++- __VOLK_ATTR_ALIGNED(16) float validBinCountVector[8];
++- _mm256_storeu_ps(validBinCountVector, vValidBinCount);
++-
++- float validBinCount = 0;
++- validBinCount += validBinCountVector[0];
++- validBinCount += validBinCountVector[1];
++- validBinCount += validBinCountVector[2];
++- validBinCount += validBinCountVector[3];
++- validBinCount += validBinCountVector[4];
++- validBinCount += validBinCountVector[5];
++- validBinCount += validBinCountVector[6];
++- validBinCount += validBinCountVector[7];
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- if(realDataPoints[number] <= meanAmplitude){
++- sumMean += realDataPoints[number];
++- validBinCount += 1.0;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const float* dataPointsPtr = realDataPoints;
+++ __VOLK_ATTR_ALIGNED(16) float avgPointsVector[8];
+++
+++ __m256 dataPointsVal;
+++ __m256 avgPointsVal = _mm256_setzero_ps();
+++ // Calculate the sum (for mean) for all points
+++ for (; number < eighthPoints; number++) {
+++
+++ dataPointsVal = _mm256_loadu_ps(dataPointsPtr);
+++
+++ dataPointsPtr += 8;
+++
+++ avgPointsVal = _mm256_add_ps(avgPointsVal, dataPointsVal);
+++ }
+++
+++ _mm256_storeu_ps(avgPointsVector, avgPointsVal);
+++
+++ float sumMean = 0.0;
+++ sumMean += avgPointsVector[0];
+++ sumMean += avgPointsVector[1];
+++ sumMean += avgPointsVector[2];
+++ sumMean += avgPointsVector[3];
+++ sumMean += avgPointsVector[4];
+++ sumMean += avgPointsVector[5];
+++ sumMean += avgPointsVector[6];
+++ sumMean += avgPointsVector[7];
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ sumMean += realDataPoints[number];
+++ }
+++
+++ // calculate the spectral mean
+++ // +20 because for the comparison below we only want to throw out bins
+++ // that are significantly higher (and would, thus, affect the mean more
+++ const float meanAmplitude = (sumMean / ((float)num_points)) + spectralExclusionValue;
+++
+++ dataPointsPtr = realDataPoints; // Reset the dataPointsPtr
+++ __m256 vMeanAmplitudeVector = _mm256_set1_ps(meanAmplitude);
+++ __m256 vOnesVector = _mm256_set1_ps(1.0);
+++ __m256 vValidBinCount = _mm256_setzero_ps();
+++ avgPointsVal = _mm256_setzero_ps();
+++ __m256 compareMask;
+++ number = 0;
+++ // Calculate the sum (for mean) for any points which do NOT exceed the mean amplitude
+++ for (; number < eighthPoints; number++) {
+++
+++ dataPointsVal = _mm256_loadu_ps(dataPointsPtr);
+++
+++ dataPointsPtr += 8;
+++
+++ // Identify which items do not exceed the mean amplitude
+++ compareMask = _mm256_cmp_ps(dataPointsVal, vMeanAmplitudeVector, _CMP_LE_OQ);
+++
+++ // Mask off the items that exceed the mean amplitude and add the avg Points that
+++ // do not exceed the mean amplitude
+++ avgPointsVal =
+++ _mm256_add_ps(avgPointsVal, _mm256_and_ps(compareMask, dataPointsVal));
+++
+++ // Count the number of bins which do not exceed the mean amplitude
+++ vValidBinCount =
+++ _mm256_add_ps(vValidBinCount, _mm256_and_ps(compareMask, vOnesVector));
+++ }
+++
+++ // Calculate the mean from the remaining data points
+++ _mm256_storeu_ps(avgPointsVector, avgPointsVal);
+++
+++ sumMean = 0.0;
+++ sumMean += avgPointsVector[0];
+++ sumMean += avgPointsVector[1];
+++ sumMean += avgPointsVector[2];
+++ sumMean += avgPointsVector[3];
+++ sumMean += avgPointsVector[4];
+++ sumMean += avgPointsVector[5];
+++ sumMean += avgPointsVector[6];
+++ sumMean += avgPointsVector[7];
+++
+++ // Calculate the number of valid bins from the remaining count
+++ __VOLK_ATTR_ALIGNED(16) float validBinCountVector[8];
+++ _mm256_storeu_ps(validBinCountVector, vValidBinCount);
+++
+++ float validBinCount = 0;
+++ validBinCount += validBinCountVector[0];
+++ validBinCount += validBinCountVector[1];
+++ validBinCount += validBinCountVector[2];
+++ validBinCount += validBinCountVector[3];
+++ validBinCount += validBinCountVector[4];
+++ validBinCount += validBinCountVector[5];
+++ validBinCount += validBinCountVector[6];
+++ validBinCount += validBinCountVector[7];
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ if (realDataPoints[number] <= meanAmplitude) {
+++ sumMean += realDataPoints[number];
+++ validBinCount += 1.0;
+++ }
++ }
++- }
++
++- float localNoiseFloorAmplitude = 0;
++- if(validBinCount > 0.0){
++- localNoiseFloorAmplitude = sumMean / validBinCount;
++- }
++- else{
++- localNoiseFloorAmplitude = meanAmplitude; // For the odd case that all the amplitudes are equal...
++- }
+++ float localNoiseFloorAmplitude = 0;
+++ if (validBinCount > 0.0) {
+++ localNoiseFloorAmplitude = sumMean / validBinCount;
+++ } else {
+++ localNoiseFloorAmplitude =
+++ meanAmplitude; // For the odd case that all the amplitudes are equal...
+++ }
++
++- *noiseFloorAmplitude = localNoiseFloorAmplitude;
+++ *noiseFloorAmplitude = localNoiseFloorAmplitude;
++ }
++ #endif /* LV_HAVE_AVX */
++ #endif /* INCLUDED_volk_32f_s32f_calc_spectral_noise_floor_32f_u_H */
++diff --git a/kernels/volk/volk_32f_s32f_convert_16i.h b/kernels/volk/volk_32f_s32f_convert_16i.h
++index 27ef4d9..c9469b7 100644
++--- a/kernels/volk/volk_32f_s32f_convert_16i.h
+++++ b/kernels/volk/volk_32f_s32f_convert_16i.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_s32f_convert_16i(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_s32f_convert_16i(int16_t* outputVector, const float* inputVector, const
+++ * float scalar, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li inputVector: the input vector of floats.
++@@ -42,11 +42,10 @@
++ * \li outputVector: The output vector.
++ *
++ * \b Example
++- * Convert floats from [-1,1] to 16-bit integers with a scale of 5 to maintain smallest delta
++- * int N = 10;
++- * unsigned int alignment = volk_get_alignment();
++- * float* increasing = (float*)volk_malloc(sizeof(float)*N, alignment);
++- * int16_t* out = (int16_t*)volk_malloc(sizeof(int16_t)*N, alignment);
+++ * Convert floats from [-1,1] to 16-bit integers with a scale of 5 to maintain smallest
+++ * delta int N = 10; unsigned int alignment = volk_get_alignment(); float* increasing =
+++ * (float*)volk_malloc(sizeof(float)*N, alignment); int16_t* out =
+++ * (int16_t*)volk_malloc(sizeof(int16_t)*N, alignment);
++ *
++ * for(unsigned int ii = 0; ii < N; ++ii){
++ * increasing[ii] = 2.f * ((float)ii / (float)N) - 1.f;
++@@ -76,55 +75,60 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_16i_u_avx2(int16_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_16i_u_avx2(int16_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int16_t* outputVectorPtr = outputVector;
++-
++- float min_val = SHRT_MIN;
++- float max_val = SHRT_MAX;
++- float r;
++-
++- __m256 vScalar = _mm256_set1_ps(scalar);
++- __m256 inputVal1, inputVal2;
++- __m256i intInputVal1, intInputVal2;
++- __m256 ret1, ret2;
++- __m256 vmin_val = _mm256_set1_ps(min_val);
++- __m256 vmax_val = _mm256_set1_ps(max_val);
++-
++- for(;number < sixteenthPoints; number++){
++- inputVal1 = _mm256_loadu_ps(inputVectorPtr); inputVectorPtr += 8;
++- inputVal2 = _mm256_loadu_ps(inputVectorPtr); inputVectorPtr += 8;
++-
++- // Scale and clip
++- ret1 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
++- ret2 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
++-
++- intInputVal1 = _mm256_cvtps_epi32(ret1);
++- intInputVal2 = _mm256_cvtps_epi32(ret2);
++-
++- intInputVal1 = _mm256_packs_epi32(intInputVal1, intInputVal2);
++- intInputVal1 = _mm256_permute4x64_epi64(intInputVal1, 0b11011000);
++-
++- _mm256_storeu_si256((__m256i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int16_t)rintf(r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int16_t* outputVectorPtr = outputVector;
+++
+++ float min_val = SHRT_MIN;
+++ float max_val = SHRT_MAX;
+++ float r;
+++
+++ __m256 vScalar = _mm256_set1_ps(scalar);
+++ __m256 inputVal1, inputVal2;
+++ __m256i intInputVal1, intInputVal2;
+++ __m256 ret1, ret2;
+++ __m256 vmin_val = _mm256_set1_ps(min_val);
+++ __m256 vmax_val = _mm256_set1_ps(max_val);
+++
+++ for (; number < sixteenthPoints; number++) {
+++ inputVal1 = _mm256_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++ inputVal2 = _mm256_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++
+++ // Scale and clip
+++ ret1 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val),
+++ vmin_val);
+++ ret2 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal2, vScalar), vmax_val),
+++ vmin_val);
+++
+++ intInputVal1 = _mm256_cvtps_epi32(ret1);
+++ intInputVal2 = _mm256_cvtps_epi32(ret2);
+++
+++ intInputVal1 = _mm256_packs_epi32(intInputVal1, intInputVal2);
+++ intInputVal1 = _mm256_permute4x64_epi64(intInputVal1, 0b11011000);
+++
+++ _mm256_storeu_si256((__m256i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int16_t)rintf(r);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -132,54 +136,57 @@ volk_32f_s32f_convert_16i_u_avx2(int16_t* outputVector, const float* inputVector
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_16i_u_avx(int16_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_16i_u_avx(int16_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
+++ unsigned int number = 0;
++
++- const unsigned int eighthPoints = num_points / 8;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- const float* inputVectorPtr = (const float*)inputVector;
++- int16_t* outputVectorPtr = outputVector;
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int16_t* outputVectorPtr = outputVector;
++
++- float min_val = SHRT_MIN;
++- float max_val = SHRT_MAX;
++- float r;
+++ float min_val = SHRT_MIN;
+++ float max_val = SHRT_MAX;
+++ float r;
++
++- __m256 vScalar = _mm256_set1_ps(scalar);
++- __m256 inputVal, ret;
++- __m256i intInputVal;
++- __m128i intInputVal1, intInputVal2;
++- __m256 vmin_val = _mm256_set1_ps(min_val);
++- __m256 vmax_val = _mm256_set1_ps(max_val);
+++ __m256 vScalar = _mm256_set1_ps(scalar);
+++ __m256 inputVal, ret;
+++ __m256i intInputVal;
+++ __m128i intInputVal1, intInputVal2;
+++ __m256 vmin_val = _mm256_set1_ps(min_val);
+++ __m256 vmax_val = _mm256_set1_ps(max_val);
++
++- for(;number < eighthPoints; number++){
++- inputVal = _mm256_loadu_ps(inputVectorPtr); inputVectorPtr += 8;
+++ for (; number < eighthPoints; number++) {
+++ inputVal = _mm256_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
++
++- // Scale and clip
++- ret = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal, vScalar), vmax_val), vmin_val);
+++ // Scale and clip
+++ ret = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal, vScalar), vmax_val),
+++ vmin_val);
++
++- intInputVal = _mm256_cvtps_epi32(ret);
+++ intInputVal = _mm256_cvtps_epi32(ret);
++
++- intInputVal1 = _mm256_extractf128_si256(intInputVal, 0);
++- intInputVal2 = _mm256_extractf128_si256(intInputVal, 1);
+++ intInputVal1 = _mm256_extractf128_si256(intInputVal, 0);
+++ intInputVal2 = _mm256_extractf128_si256(intInputVal, 1);
++
++- intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
+++ intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
++
++- _mm_storeu_si128((__m128i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 8;
++- }
+++ _mm_storeu_si128((__m128i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int16_t)rintf(r);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int16_t)rintf(r);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -187,54 +194,57 @@ volk_32f_s32f_convert_16i_u_avx(int16_t* outputVector, const float* inputVector,
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_16i_u_sse2(int16_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_16i_u_sse2(int16_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int16_t* outputVectorPtr = outputVector;
++-
++- float min_val = SHRT_MIN;
++- float max_val = SHRT_MAX;
++- float r;
++-
++- __m128 vScalar = _mm_set_ps1(scalar);
++- __m128 inputVal1, inputVal2;
++- __m128i intInputVal1, intInputVal2;
++- __m128 ret1, ret2;
++- __m128 vmin_val = _mm_set_ps1(min_val);
++- __m128 vmax_val = _mm_set_ps1(max_val);
++-
++- for(;number < eighthPoints; number++){
++- inputVal1 = _mm_loadu_ps(inputVectorPtr); inputVectorPtr += 4;
++- inputVal2 = _mm_loadu_ps(inputVectorPtr); inputVectorPtr += 4;
++-
++- // Scale and clip
++- ret1 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
++- ret2 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
++-
++- intInputVal1 = _mm_cvtps_epi32(ret1);
++- intInputVal2 = _mm_cvtps_epi32(ret2);
++-
++- intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
++-
++- _mm_storeu_si128((__m128i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int16_t)rintf(r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int16_t* outputVectorPtr = outputVector;
+++
+++ float min_val = SHRT_MIN;
+++ float max_val = SHRT_MAX;
+++ float r;
+++
+++ __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 inputVal1, inputVal2;
+++ __m128i intInputVal1, intInputVal2;
+++ __m128 ret1, ret2;
+++ __m128 vmin_val = _mm_set_ps1(min_val);
+++ __m128 vmax_val = _mm_set_ps1(max_val);
+++
+++ for (; number < eighthPoints; number++) {
+++ inputVal1 = _mm_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++ inputVal2 = _mm_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++
+++ // Scale and clip
+++ ret1 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
+++ ret2 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
+++
+++ intInputVal1 = _mm_cvtps_epi32(ret1);
+++ intInputVal2 = _mm_cvtps_epi32(ret2);
+++
+++ intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
+++
+++ _mm_storeu_si128((__m128i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int16_t)rintf(r);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++@@ -242,76 +252,78 @@ volk_32f_s32f_convert_16i_u_sse2(int16_t* outputVector, const float* inputVector
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_16i_u_sse(int16_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_16i_u_sse(int16_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int16_t* outputVectorPtr = outputVector;
++-
++- float min_val = SHRT_MIN;
++- float max_val = SHRT_MAX;
++- float r;
++-
++- __m128 vScalar = _mm_set_ps1(scalar);
++- __m128 ret;
++- __m128 vmin_val = _mm_set_ps1(min_val);
++- __m128 vmax_val = _mm_set_ps1(max_val);
++-
++- __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
++-
++- for(;number < quarterPoints; number++){
++- ret = _mm_loadu_ps(inputVectorPtr);
++- inputVectorPtr += 4;
++-
++- // Scale and clip
++- ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
++-
++- _mm_store_ps(outputFloatBuffer, ret);
++- *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[0]);
++- *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[1]);
++- *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[2]);
++- *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[3]);
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int16_t)rintf(r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int16_t* outputVectorPtr = outputVector;
+++
+++ float min_val = SHRT_MIN;
+++ float max_val = SHRT_MAX;
+++ float r;
+++
+++ __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 ret;
+++ __m128 vmin_val = _mm_set_ps1(min_val);
+++ __m128 vmax_val = _mm_set_ps1(max_val);
+++
+++ __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
+++
+++ for (; number < quarterPoints; number++) {
+++ ret = _mm_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++
+++ // Scale and clip
+++ ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
+++
+++ _mm_store_ps(outputFloatBuffer, ret);
+++ *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[0]);
+++ *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[1]);
+++ *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[2]);
+++ *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[3]);
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int16_t)rintf(r);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_s32f_convert_16i_generic(int16_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_16i_generic(int16_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- int16_t* outputVectorPtr = outputVector;
++- const float* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++- float min_val = SHRT_MIN;
++- float max_val = SHRT_MAX;
++- float r;
++-
++- for(number = 0; number < num_points; number++){
++- r = *inputVectorPtr++ * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- *outputVectorPtr++ = (int16_t)rintf(r);
++- }
+++ int16_t* outputVectorPtr = outputVector;
+++ const float* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++ float min_val = SHRT_MIN;
+++ float max_val = SHRT_MAX;
+++ float r;
+++
+++ for (number = 0; number < num_points; number++) {
+++ r = *inputVectorPtr++ * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ *outputVectorPtr++ = (int16_t)rintf(r);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -320,63 +332,68 @@ volk_32f_s32f_convert_16i_generic(int16_t* outputVector, const float* inputVecto
++ #ifndef INCLUDED_volk_32f_s32f_convert_16i_a_H
++ #define INCLUDED_volk_32f_s32f_convert_16i_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_16i_a_avx2(int16_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_16i_a_avx2(int16_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int16_t* outputVectorPtr = outputVector;
++-
++- float min_val = SHRT_MIN;
++- float max_val = SHRT_MAX;
++- float r;
++-
++- __m256 vScalar = _mm256_set1_ps(scalar);
++- __m256 inputVal1, inputVal2;
++- __m256i intInputVal1, intInputVal2;
++- __m256 ret1, ret2;
++- __m256 vmin_val = _mm256_set1_ps(min_val);
++- __m256 vmax_val = _mm256_set1_ps(max_val);
++-
++- for(;number < sixteenthPoints; number++){
++- inputVal1 = _mm256_load_ps(inputVectorPtr); inputVectorPtr += 8;
++- inputVal2 = _mm256_load_ps(inputVectorPtr); inputVectorPtr += 8;
++-
++- // Scale and clip
++- ret1 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
++- ret2 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
++-
++- intInputVal1 = _mm256_cvtps_epi32(ret1);
++- intInputVal2 = _mm256_cvtps_epi32(ret2);
++-
++- intInputVal1 = _mm256_packs_epi32(intInputVal1, intInputVal2);
++- intInputVal1 = _mm256_permute4x64_epi64(intInputVal1, 0b11011000);
++-
++- _mm256_store_si256((__m256i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int16_t)rintf(r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int16_t* outputVectorPtr = outputVector;
+++
+++ float min_val = SHRT_MIN;
+++ float max_val = SHRT_MAX;
+++ float r;
+++
+++ __m256 vScalar = _mm256_set1_ps(scalar);
+++ __m256 inputVal1, inputVal2;
+++ __m256i intInputVal1, intInputVal2;
+++ __m256 ret1, ret2;
+++ __m256 vmin_val = _mm256_set1_ps(min_val);
+++ __m256 vmax_val = _mm256_set1_ps(max_val);
+++
+++ for (; number < sixteenthPoints; number++) {
+++ inputVal1 = _mm256_load_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++ inputVal2 = _mm256_load_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++
+++ // Scale and clip
+++ ret1 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val),
+++ vmin_val);
+++ ret2 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal2, vScalar), vmax_val),
+++ vmin_val);
+++
+++ intInputVal1 = _mm256_cvtps_epi32(ret1);
+++ intInputVal2 = _mm256_cvtps_epi32(ret2);
+++
+++ intInputVal1 = _mm256_packs_epi32(intInputVal1, intInputVal2);
+++ intInputVal1 = _mm256_permute4x64_epi64(intInputVal1, 0b11011000);
+++
+++ _mm256_store_si256((__m256i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int16_t)rintf(r);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -384,108 +401,114 @@ volk_32f_s32f_convert_16i_a_avx2(int16_t* outputVector, const float* inputVector
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_16i_a_avx(int16_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_16i_a_avx(int16_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
+++ unsigned int number = 0;
++
++- const unsigned int eighthPoints = num_points / 8;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- const float* inputVectorPtr = (const float*)inputVector;
++- int16_t* outputVectorPtr = outputVector;
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int16_t* outputVectorPtr = outputVector;
++
++- float min_val = SHRT_MIN;
++- float max_val = SHRT_MAX;
++- float r;
+++ float min_val = SHRT_MIN;
+++ float max_val = SHRT_MAX;
+++ float r;
++
++- __m256 vScalar = _mm256_set1_ps(scalar);
++- __m256 inputVal, ret;
++- __m256i intInputVal;
++- __m128i intInputVal1, intInputVal2;
++- __m256 vmin_val = _mm256_set1_ps(min_val);
++- __m256 vmax_val = _mm256_set1_ps(max_val);
+++ __m256 vScalar = _mm256_set1_ps(scalar);
+++ __m256 inputVal, ret;
+++ __m256i intInputVal;
+++ __m128i intInputVal1, intInputVal2;
+++ __m256 vmin_val = _mm256_set1_ps(min_val);
+++ __m256 vmax_val = _mm256_set1_ps(max_val);
++
++- for(;number < eighthPoints; number++){
++- inputVal = _mm256_load_ps(inputVectorPtr); inputVectorPtr += 8;
+++ for (; number < eighthPoints; number++) {
+++ inputVal = _mm256_load_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
++
++- // Scale and clip
++- ret = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal, vScalar), vmax_val), vmin_val);
+++ // Scale and clip
+++ ret = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal, vScalar), vmax_val),
+++ vmin_val);
++
++- intInputVal = _mm256_cvtps_epi32(ret);
+++ intInputVal = _mm256_cvtps_epi32(ret);
++
++- intInputVal1 = _mm256_extractf128_si256(intInputVal, 0);
++- intInputVal2 = _mm256_extractf128_si256(intInputVal, 1);
+++ intInputVal1 = _mm256_extractf128_si256(intInputVal, 0);
+++ intInputVal2 = _mm256_extractf128_si256(intInputVal, 1);
++
++- intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
+++ intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
++
++- _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 8;
++- }
+++ _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int16_t)rintf(r);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int16_t)rintf(r);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_16i_a_sse2(int16_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_16i_a_sse2(int16_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int16_t* outputVectorPtr = outputVector;
++-
++- float min_val = SHRT_MIN;
++- float max_val = SHRT_MAX;
++- float r;
++-
++- __m128 vScalar = _mm_set_ps1(scalar);
++- __m128 inputVal1, inputVal2;
++- __m128i intInputVal1, intInputVal2;
++- __m128 ret1, ret2;
++- __m128 vmin_val = _mm_set_ps1(min_val);
++- __m128 vmax_val = _mm_set_ps1(max_val);
++-
++- for(;number < eighthPoints; number++){
++- inputVal1 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;
++- inputVal2 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;
++-
++- // Scale and clip
++- ret1 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
++- ret2 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
++-
++- intInputVal1 = _mm_cvtps_epi32(ret1);
++- intInputVal2 = _mm_cvtps_epi32(ret2);
++-
++- intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
++-
++- _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int16_t)rintf(r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int16_t* outputVectorPtr = outputVector;
+++
+++ float min_val = SHRT_MIN;
+++ float max_val = SHRT_MAX;
+++ float r;
+++
+++ __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 inputVal1, inputVal2;
+++ __m128i intInputVal1, intInputVal2;
+++ __m128 ret1, ret2;
+++ __m128 vmin_val = _mm_set_ps1(min_val);
+++ __m128 vmax_val = _mm_set_ps1(max_val);
+++
+++ for (; number < eighthPoints; number++) {
+++ inputVal1 = _mm_load_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++ inputVal2 = _mm_load_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++
+++ // Scale and clip
+++ ret1 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
+++ ret2 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
+++
+++ intInputVal1 = _mm_cvtps_epi32(ret1);
+++ intInputVal2 = _mm_cvtps_epi32(ret2);
+++
+++ intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
+++
+++ _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int16_t)rintf(r);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++@@ -493,76 +516,78 @@ volk_32f_s32f_convert_16i_a_sse2(int16_t* outputVector, const float* inputVector
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_16i_a_sse(int16_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_16i_a_sse(int16_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int16_t* outputVectorPtr = outputVector;
++-
++- float min_val = SHRT_MIN;
++- float max_val = SHRT_MAX;
++- float r;
++-
++- __m128 vScalar = _mm_set_ps1(scalar);
++- __m128 ret;
++- __m128 vmin_val = _mm_set_ps1(min_val);
++- __m128 vmax_val = _mm_set_ps1(max_val);
++-
++- __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
++-
++- for(;number < quarterPoints; number++){
++- ret = _mm_load_ps(inputVectorPtr);
++- inputVectorPtr += 4;
++-
++- // Scale and clip
++- ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
++-
++- _mm_store_ps(outputFloatBuffer, ret);
++- *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[0]);
++- *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[1]);
++- *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[2]);
++- *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[3]);
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int16_t)rintf(r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int16_t* outputVectorPtr = outputVector;
+++
+++ float min_val = SHRT_MIN;
+++ float max_val = SHRT_MAX;
+++ float r;
+++
+++ __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 ret;
+++ __m128 vmin_val = _mm_set_ps1(min_val);
+++ __m128 vmax_val = _mm_set_ps1(max_val);
+++
+++ __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
+++
+++ for (; number < quarterPoints; number++) {
+++ ret = _mm_load_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++
+++ // Scale and clip
+++ ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
+++
+++ _mm_store_ps(outputFloatBuffer, ret);
+++ *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[0]);
+++ *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[1]);
+++ *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[2]);
+++ *outputVectorPtr++ = (int16_t)rintf(outputFloatBuffer[3]);
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int16_t)rintf(r);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_s32f_convert_16i_a_generic(int16_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_16i_a_generic(int16_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- int16_t* outputVectorPtr = outputVector;
++- const float* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++- float min_val = SHRT_MIN;
++- float max_val = SHRT_MAX;
++- float r;
++-
++- for(number = 0; number < num_points; number++){
++- r = *inputVectorPtr++ * scalar;
++- if(r < min_val)
++- r = min_val;
++- else if(r > max_val)
++- r = max_val;
++- *outputVectorPtr++ = (int16_t)rintf(r);
++- }
+++ int16_t* outputVectorPtr = outputVector;
+++ const float* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++ float min_val = SHRT_MIN;
+++ float max_val = SHRT_MAX;
+++ float r;
+++
+++ for (number = 0; number < num_points; number++) {
+++ r = *inputVectorPtr++ * scalar;
+++ if (r < min_val)
+++ r = min_val;
+++ else if (r > max_val)
+++ r = max_val;
+++ *outputVectorPtr++ = (int16_t)rintf(r);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32f_s32f_convert_32i.h b/kernels/volk/volk_32f_s32f_convert_32i.h
++index d2a65a0..d5f7cd4 100644
++--- a/kernels/volk/volk_32f_s32f_convert_32i.h
+++++ b/kernels/volk/volk_32f_s32f_convert_32i.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_s32f_convert_32i(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_s32f_convert_32i(int32_t* outputVector, const float* inputVector, const
+++ * float scalar, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li inputVector: the input vector of floats.
++@@ -77,46 +77,49 @@
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_32i_u_avx(int32_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_32i_u_avx(int32_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int32_t* outputVectorPtr = outputVector;
++-
++- float min_val = INT_MIN;
++- float max_val = INT_MAX;
++- float r;
++-
++- __m256 vScalar = _mm256_set1_ps(scalar);
++- __m256 inputVal1;
++- __m256i intInputVal1;
++- __m256 vmin_val = _mm256_set1_ps(min_val);
++- __m256 vmax_val = _mm256_set1_ps(max_val);
++-
++- for(;number < eighthPoints; number++){
++- inputVal1 = _mm256_loadu_ps(inputVectorPtr); inputVectorPtr += 8;
++-
++- inputVal1 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
++- intInputVal1 = _mm256_cvtps_epi32(inputVal1);
++-
++- _mm256_storeu_si256((__m256i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int32_t)rintf(r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int32_t* outputVectorPtr = outputVector;
+++
+++ float min_val = INT_MIN;
+++ float max_val = INT_MAX;
+++ float r;
+++
+++ __m256 vScalar = _mm256_set1_ps(scalar);
+++ __m256 inputVal1;
+++ __m256i intInputVal1;
+++ __m256 vmin_val = _mm256_set1_ps(min_val);
+++ __m256 vmax_val = _mm256_set1_ps(max_val);
+++
+++ for (; number < eighthPoints; number++) {
+++ inputVal1 = _mm256_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++
+++ inputVal1 = _mm256_max_ps(
+++ _mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
+++ intInputVal1 = _mm256_cvtps_epi32(inputVal1);
+++
+++ _mm256_storeu_si256((__m256i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int32_t)rintf(r);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++@@ -124,46 +127,49 @@ volk_32f_s32f_convert_32i_u_avx(int32_t* outputVector, const float* inputVector,
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_32i_u_sse2(int32_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_32i_u_sse2(int32_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int32_t* outputVectorPtr = outputVector;
++-
++- float min_val = INT_MIN;
++- float max_val = INT_MAX;
++- float r;
++-
++- __m128 vScalar = _mm_set_ps1(scalar);
++- __m128 inputVal1;
++- __m128i intInputVal1;
++- __m128 vmin_val = _mm_set_ps1(min_val);
++- __m128 vmax_val = _mm_set_ps1(max_val);
++-
++- for(;number < quarterPoints; number++){
++- inputVal1 = _mm_loadu_ps(inputVectorPtr); inputVectorPtr += 4;
++-
++- inputVal1 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
++- intInputVal1 = _mm_cvtps_epi32(inputVal1);
++-
++- _mm_storeu_si128((__m128i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int32_t)rintf(r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int32_t* outputVectorPtr = outputVector;
+++
+++ float min_val = INT_MIN;
+++ float max_val = INT_MAX;
+++ float r;
+++
+++ __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 inputVal1;
+++ __m128i intInputVal1;
+++ __m128 vmin_val = _mm_set_ps1(min_val);
+++ __m128 vmax_val = _mm_set_ps1(max_val);
+++
+++ for (; number < quarterPoints; number++) {
+++ inputVal1 = _mm_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++
+++ inputVal1 =
+++ _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
+++ intInputVal1 = _mm_cvtps_epi32(inputVal1);
+++
+++ _mm_storeu_si128((__m128i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int32_t)rintf(r);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE2 */
++@@ -172,50 +178,51 @@ volk_32f_s32f_convert_32i_u_sse2(int32_t* outputVector, const float* inputVector
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_32i_u_sse(int32_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_32i_u_sse(int32_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int32_t* outputVectorPtr = outputVector;
++-
++- float min_val = INT_MIN;
++- float max_val = INT_MAX;
++- float r;
++-
++- __m128 vScalar = _mm_set_ps1(scalar);
++- __m128 ret;
++- __m128 vmin_val = _mm_set_ps1(min_val);
++- __m128 vmax_val = _mm_set_ps1(max_val);
++-
++- __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
++-
++- for(;number < quarterPoints; number++){
++- ret = _mm_loadu_ps(inputVectorPtr);
++- inputVectorPtr += 4;
++-
++- ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
++-
++- _mm_store_ps(outputFloatBuffer, ret);
++- *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[0]);
++- *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[1]);
++- *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[2]);
++- *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[3]);
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int32_t)rintf(r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int32_t* outputVectorPtr = outputVector;
+++
+++ float min_val = INT_MIN;
+++ float max_val = INT_MAX;
+++ float r;
+++
+++ __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 ret;
+++ __m128 vmin_val = _mm_set_ps1(min_val);
+++ __m128 vmax_val = _mm_set_ps1(max_val);
+++
+++ __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
+++
+++ for (; number < quarterPoints; number++) {
+++ ret = _mm_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++
+++ ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
+++
+++ _mm_store_ps(outputFloatBuffer, ret);
+++ *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[0]);
+++ *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[1]);
+++ *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[2]);
+++ *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[3]);
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int32_t)rintf(r);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE */
++@@ -223,82 +230,85 @@ volk_32f_s32f_convert_32i_u_sse(int32_t* outputVector, const float* inputVector,
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_s32f_convert_32i_generic(int32_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_32i_generic(int32_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- int32_t* outputVectorPtr = outputVector;
++- const float* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++- float min_val = INT_MIN;
++- float max_val = INT_MAX;
++- float r;
++-
++- for(number = 0; number < num_points; number++){
++- r = *inputVectorPtr++ * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- *outputVectorPtr++ = (int32_t)rintf(r);
++- }
+++ int32_t* outputVectorPtr = outputVector;
+++ const float* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++ float min_val = INT_MIN;
+++ float max_val = INT_MAX;
+++ float r;
+++
+++ for (number = 0; number < num_points; number++) {
+++ r = *inputVectorPtr++ * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ *outputVectorPtr++ = (int32_t)rintf(r);
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++ #endif /* INCLUDED_volk_32f_s32f_convert_32i_u_H */
++ #ifndef INCLUDED_volk_32f_s32f_convert_32i_a_H
++ #define INCLUDED_volk_32f_s32f_convert_32i_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_32i_a_avx(int32_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_32i_a_avx(int32_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int32_t* outputVectorPtr = outputVector;
++-
++- float min_val = INT_MIN;
++- float max_val = INT_MAX;
++- float r;
++-
++- __m256 vScalar = _mm256_set1_ps(scalar);
++- __m256 inputVal1;
++- __m256i intInputVal1;
++- __m256 vmin_val = _mm256_set1_ps(min_val);
++- __m256 vmax_val = _mm256_set1_ps(max_val);
++-
++- for(;number < eighthPoints; number++){
++- inputVal1 = _mm256_load_ps(inputVectorPtr); inputVectorPtr += 8;
++-
++- inputVal1 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
++- intInputVal1 = _mm256_cvtps_epi32(inputVal1);
++-
++- _mm256_store_si256((__m256i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int32_t)rintf(r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int32_t* outputVectorPtr = outputVector;
+++
+++ float min_val = INT_MIN;
+++ float max_val = INT_MAX;
+++ float r;
+++
+++ __m256 vScalar = _mm256_set1_ps(scalar);
+++ __m256 inputVal1;
+++ __m256i intInputVal1;
+++ __m256 vmin_val = _mm256_set1_ps(min_val);
+++ __m256 vmax_val = _mm256_set1_ps(max_val);
+++
+++ for (; number < eighthPoints; number++) {
+++ inputVal1 = _mm256_load_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++
+++ inputVal1 = _mm256_max_ps(
+++ _mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
+++ intInputVal1 = _mm256_cvtps_epi32(inputVal1);
+++
+++ _mm256_store_si256((__m256i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int32_t)rintf(r);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++@@ -307,46 +317,49 @@ volk_32f_s32f_convert_32i_a_avx(int32_t* outputVector, const float* inputVector,
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_32i_a_sse2(int32_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_32i_a_sse2(int32_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int32_t* outputVectorPtr = outputVector;
++-
++- float min_val = INT_MIN;
++- float max_val = INT_MAX;
++- float r;
++-
++- __m128 vScalar = _mm_set_ps1(scalar);
++- __m128 inputVal1;
++- __m128i intInputVal1;
++- __m128 vmin_val = _mm_set_ps1(min_val);
++- __m128 vmax_val = _mm_set_ps1(max_val);
++-
++- for(;number < quarterPoints; number++){
++- inputVal1 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;
++-
++- inputVal1 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
++- intInputVal1 = _mm_cvtps_epi32(inputVal1);
++-
++- _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int32_t)rintf(r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int32_t* outputVectorPtr = outputVector;
+++
+++ float min_val = INT_MIN;
+++ float max_val = INT_MAX;
+++ float r;
+++
+++ __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 inputVal1;
+++ __m128i intInputVal1;
+++ __m128 vmin_val = _mm_set_ps1(min_val);
+++ __m128 vmax_val = _mm_set_ps1(max_val);
+++
+++ for (; number < quarterPoints; number++) {
+++ inputVal1 = _mm_load_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++
+++ inputVal1 =
+++ _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
+++ intInputVal1 = _mm_cvtps_epi32(inputVal1);
+++
+++ _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int32_t)rintf(r);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE2 */
++@@ -355,50 +368,51 @@ volk_32f_s32f_convert_32i_a_sse2(int32_t* outputVector, const float* inputVector
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_32i_a_sse(int32_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_32i_a_sse(int32_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int32_t* outputVectorPtr = outputVector;
++-
++- float min_val = INT_MIN;
++- float max_val = INT_MAX;
++- float r;
++-
++- __m128 vScalar = _mm_set_ps1(scalar);
++- __m128 ret;
++- __m128 vmin_val = _mm_set_ps1(min_val);
++- __m128 vmax_val = _mm_set_ps1(max_val);
++-
++- __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
++-
++- for(;number < quarterPoints; number++){
++- ret = _mm_load_ps(inputVectorPtr);
++- inputVectorPtr += 4;
++-
++- ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
++-
++- _mm_store_ps(outputFloatBuffer, ret);
++- *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[0]);
++- *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[1]);
++- *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[2]);
++- *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[3]);
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- outputVector[number] = (int32_t)rintf(r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int32_t* outputVectorPtr = outputVector;
+++
+++ float min_val = INT_MIN;
+++ float max_val = INT_MAX;
+++ float r;
+++
+++ __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 ret;
+++ __m128 vmin_val = _mm_set_ps1(min_val);
+++ __m128 vmax_val = _mm_set_ps1(max_val);
+++
+++ __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
+++
+++ for (; number < quarterPoints; number++) {
+++ ret = _mm_load_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++
+++ ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
+++
+++ _mm_store_ps(outputFloatBuffer, ret);
+++ *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[0]);
+++ *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[1]);
+++ *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[2]);
+++ *outputVectorPtr++ = (int32_t)rintf(outputFloatBuffer[3]);
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ outputVector[number] = (int32_t)rintf(r);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE */
++@@ -406,25 +420,26 @@ volk_32f_s32f_convert_32i_a_sse(int32_t* outputVector, const float* inputVector,
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_s32f_convert_32i_a_generic(int32_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_32i_a_generic(int32_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- int32_t* outputVectorPtr = outputVector;
++- const float* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++- float min_val = INT_MIN;
++- float max_val = INT_MAX;
++- float r;
++-
++- for(number = 0; number < num_points; number++){
++- r = *inputVectorPtr++ * scalar;
++- if(r > max_val)
++- r = max_val;
++- else if(r < min_val)
++- r = min_val;
++- *outputVectorPtr++ = (int32_t)rintf(r);
++- }
+++ int32_t* outputVectorPtr = outputVector;
+++ const float* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++ float min_val = INT_MIN;
+++ float max_val = INT_MAX;
+++ float r;
+++
+++ for (number = 0; number < num_points; number++) {
+++ r = *inputVectorPtr++ * scalar;
+++ if (r > max_val)
+++ r = max_val;
+++ else if (r < min_val)
+++ r = min_val;
+++ *outputVectorPtr++ = (int32_t)rintf(r);
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++diff --git a/kernels/volk/volk_32f_s32f_convert_8i.h b/kernels/volk/volk_32f_s32f_convert_8i.h
++index 2a1669c..242c3bd 100644
++--- a/kernels/volk/volk_32f_s32f_convert_8i.h
+++++ b/kernels/volk/volk_32f_s32f_convert_8i.h
++@@ -30,7 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_s32f_convert_8i(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points)
+++ * void volk_32f_s32f_convert_8i(int8_t* outputVector, const float* inputVector, const
+++ float scalar, unsigned int num_points)
++ * \endcode
++ *
++ * \b Inputs
++@@ -42,7 +43,8 @@
++ * \li outputVector: The output vector.
++ *
++ * \b Example
++- * Convert floats from [-1,1] to 16-bit integers with a scale of 5 to maintain smallest delta
+++ * Convert floats from [-1,1] to 16-bit integers with a scale of 5 to maintain smallest
+++ delta
++ * int N = 10;
++ * unsigned int alignment = volk_get_alignment();
++ * float* increasing = (float*)volk_malloc(sizeof(float)*N, alignment);
++@@ -74,77 +76,86 @@
++ #include <inttypes.h>
++ #include <stdio.h>
++
++-static inline void
++-volk_32f_s32f_convert_8i_single(int8_t* out, const float in){
++- float min_val = CHAR_MIN;
++- float max_val = CHAR_MAX;
++- if(in > max_val){
++- *out = (int8_t)(max_val);
++- }else if(in < min_val){
++- *out = (int8_t)(min_val);
++- }else{
++- *out = (int8_t)(rintf(in));
++- }
+++static inline void volk_32f_s32f_convert_8i_single(int8_t* out, const float in)
+++{
+++ float min_val = CHAR_MIN;
+++ float max_val = CHAR_MAX;
+++ if (in > max_val) {
+++ *out = (int8_t)(max_val);
+++ } else if (in < min_val) {
+++ *out = (int8_t)(min_val);
+++ } else {
+++ *out = (int8_t)(rintf(in));
+++ }
++ }
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_8i_u_avx2(int8_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_8i_u_avx2(int8_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int thirtysecondPoints = num_points / 32;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int8_t* outputVectorPtr = outputVector;
++-
++- float min_val = CHAR_MIN;
++- float max_val = CHAR_MAX;
++- float r;
++-
++- __m256 vScalar = _mm256_set1_ps(scalar);
++- __m256 inputVal1, inputVal2, inputVal3, inputVal4;
++- __m256i intInputVal1, intInputVal2, intInputVal3, intInputVal4;
++- __m256 vmin_val = _mm256_set1_ps(min_val);
++- __m256 vmax_val = _mm256_set1_ps(max_val);
++- __m256i intInputVal;
++-
++- for(;number < thirtysecondPoints; number++){
++- inputVal1 = _mm256_loadu_ps(inputVectorPtr); inputVectorPtr += 8;
++- inputVal2 = _mm256_loadu_ps(inputVectorPtr); inputVectorPtr += 8;
++- inputVal3 = _mm256_loadu_ps(inputVectorPtr); inputVectorPtr += 8;
++- inputVal4 = _mm256_loadu_ps(inputVectorPtr); inputVectorPtr += 8;
++-
++- inputVal1 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
++- inputVal2 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
++- inputVal3 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal3, vScalar), vmax_val), vmin_val);
++- inputVal4 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal4, vScalar), vmax_val), vmin_val);
++-
++- intInputVal1 = _mm256_cvtps_epi32(inputVal1);
++- intInputVal2 = _mm256_cvtps_epi32(inputVal2);
++- intInputVal3 = _mm256_cvtps_epi32(inputVal3);
++- intInputVal4 = _mm256_cvtps_epi32(inputVal4);
++-
++- intInputVal1 = _mm256_packs_epi32(intInputVal1, intInputVal2);
++- intInputVal1 = _mm256_permute4x64_epi64(intInputVal1, 0b11011000);
++- intInputVal3 = _mm256_packs_epi32(intInputVal3, intInputVal4);
++- intInputVal3 = _mm256_permute4x64_epi64(intInputVal3, 0b11011000);
++-
++- intInputVal1 = _mm256_packs_epi16(intInputVal1, intInputVal3);
++- intInputVal = _mm256_permute4x64_epi64(intInputVal1, 0b11011000);
++-
++- _mm256_storeu_si256((__m256i*)outputVectorPtr, intInputVal);
++- outputVectorPtr += 32;
++- }
++-
++- number = thirtysecondPoints * 32;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- volk_32f_s32f_convert_8i_single(&outputVector[number], r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int thirtysecondPoints = num_points / 32;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int8_t* outputVectorPtr = outputVector;
+++
+++ float min_val = CHAR_MIN;
+++ float max_val = CHAR_MAX;
+++ float r;
+++
+++ __m256 vScalar = _mm256_set1_ps(scalar);
+++ __m256 inputVal1, inputVal2, inputVal3, inputVal4;
+++ __m256i intInputVal1, intInputVal2, intInputVal3, intInputVal4;
+++ __m256 vmin_val = _mm256_set1_ps(min_val);
+++ __m256 vmax_val = _mm256_set1_ps(max_val);
+++ __m256i intInputVal;
+++
+++ for (; number < thirtysecondPoints; number++) {
+++ inputVal1 = _mm256_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++ inputVal2 = _mm256_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++ inputVal3 = _mm256_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++ inputVal4 = _mm256_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++
+++ inputVal1 = _mm256_max_ps(
+++ _mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
+++ inputVal2 = _mm256_max_ps(
+++ _mm256_min_ps(_mm256_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
+++ inputVal3 = _mm256_max_ps(
+++ _mm256_min_ps(_mm256_mul_ps(inputVal3, vScalar), vmax_val), vmin_val);
+++ inputVal4 = _mm256_max_ps(
+++ _mm256_min_ps(_mm256_mul_ps(inputVal4, vScalar), vmax_val), vmin_val);
+++
+++ intInputVal1 = _mm256_cvtps_epi32(inputVal1);
+++ intInputVal2 = _mm256_cvtps_epi32(inputVal2);
+++ intInputVal3 = _mm256_cvtps_epi32(inputVal3);
+++ intInputVal4 = _mm256_cvtps_epi32(inputVal4);
+++
+++ intInputVal1 = _mm256_packs_epi32(intInputVal1, intInputVal2);
+++ intInputVal1 = _mm256_permute4x64_epi64(intInputVal1, 0b11011000);
+++ intInputVal3 = _mm256_packs_epi32(intInputVal3, intInputVal4);
+++ intInputVal3 = _mm256_permute4x64_epi64(intInputVal3, 0b11011000);
+++
+++ intInputVal1 = _mm256_packs_epi16(intInputVal1, intInputVal3);
+++ intInputVal = _mm256_permute4x64_epi64(intInputVal1, 0b11011000);
+++
+++ _mm256_storeu_si256((__m256i*)outputVectorPtr, intInputVal);
+++ outputVectorPtr += 32;
+++ }
+++
+++ number = thirtysecondPoints * 32;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ volk_32f_s32f_convert_8i_single(&outputVector[number], r);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 */
++@@ -153,57 +164,66 @@ volk_32f_s32f_convert_8i_u_avx2(int8_t* outputVector, const float* inputVector,
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_8i_u_sse2(int8_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_8i_u_sse2(int8_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int8_t* outputVectorPtr = outputVector;
++-
++- float min_val = CHAR_MIN;
++- float max_val = CHAR_MAX;
++- float r;
++-
++- __m128 vScalar = _mm_set_ps1(scalar);
++- __m128 inputVal1, inputVal2, inputVal3, inputVal4;
++- __m128i intInputVal1, intInputVal2, intInputVal3, intInputVal4;
++- __m128 vmin_val = _mm_set_ps1(min_val);
++- __m128 vmax_val = _mm_set_ps1(max_val);
++-
++- for(;number < sixteenthPoints; number++){
++- inputVal1 = _mm_loadu_ps(inputVectorPtr); inputVectorPtr += 4;
++- inputVal2 = _mm_loadu_ps(inputVectorPtr); inputVectorPtr += 4;
++- inputVal3 = _mm_loadu_ps(inputVectorPtr); inputVectorPtr += 4;
++- inputVal4 = _mm_loadu_ps(inputVectorPtr); inputVectorPtr += 4;
++-
++- inputVal1 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
++- inputVal2 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
++- inputVal3 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal3, vScalar), vmax_val), vmin_val);
++- inputVal4 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal4, vScalar), vmax_val), vmin_val);
++-
++- intInputVal1 = _mm_cvtps_epi32(inputVal1);
++- intInputVal2 = _mm_cvtps_epi32(inputVal2);
++- intInputVal3 = _mm_cvtps_epi32(inputVal3);
++- intInputVal4 = _mm_cvtps_epi32(inputVal4);
++-
++- intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
++- intInputVal3 = _mm_packs_epi32(intInputVal3, intInputVal4);
++-
++- intInputVal1 = _mm_packs_epi16(intInputVal1, intInputVal3);
++-
++- _mm_storeu_si128((__m128i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 16;
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int8_t* outputVectorPtr = outputVector;
+++
+++ float min_val = CHAR_MIN;
+++ float max_val = CHAR_MAX;
+++ float r;
+++
+++ __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 inputVal1, inputVal2, inputVal3, inputVal4;
+++ __m128i intInputVal1, intInputVal2, intInputVal3, intInputVal4;
+++ __m128 vmin_val = _mm_set_ps1(min_val);
+++ __m128 vmax_val = _mm_set_ps1(max_val);
+++
+++ for (; number < sixteenthPoints; number++) {
+++ inputVal1 = _mm_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++ inputVal2 = _mm_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++ inputVal3 = _mm_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++ inputVal4 = _mm_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++
+++ inputVal1 =
+++ _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
+++ inputVal2 =
+++ _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
+++ inputVal3 =
+++ _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal3, vScalar), vmax_val), vmin_val);
+++ inputVal4 =
+++ _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal4, vScalar), vmax_val), vmin_val);
+++
+++ intInputVal1 = _mm_cvtps_epi32(inputVal1);
+++ intInputVal2 = _mm_cvtps_epi32(inputVal2);
+++ intInputVal3 = _mm_cvtps_epi32(inputVal3);
+++ intInputVal4 = _mm_cvtps_epi32(inputVal4);
+++
+++ intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
+++ intInputVal3 = _mm_packs_epi32(intInputVal3, intInputVal4);
+++
+++ intInputVal1 = _mm_packs_epi16(intInputVal1, intInputVal3);
+++
+++ _mm_storeu_si128((__m128i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- volk_32f_s32f_convert_8i_single(&outputVector[number], r);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ volk_32f_s32f_convert_8i_single(&outputVector[number], r);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE2 */
++@@ -212,46 +232,47 @@ volk_32f_s32f_convert_8i_u_sse2(int8_t* outputVector, const float* inputVector,
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_8i_u_sse(int8_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_8i_u_sse(int8_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- size_t inner_loop;
+++ unsigned int number = 0;
+++ size_t inner_loop;
++
++- const unsigned int quarterPoints = num_points / 4;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* inputVectorPtr = (const float*)inputVector;
++- int8_t* outputVectorPtr = outputVector;
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int8_t* outputVectorPtr = outputVector;
++
++- float min_val = CHAR_MIN;
++- float max_val = CHAR_MAX;
++- float r;
+++ float min_val = CHAR_MIN;
+++ float max_val = CHAR_MAX;
+++ float r;
++
++- __m128 vScalar = _mm_set_ps1(scalar);
++- __m128 ret;
++- __m128 vmin_val = _mm_set_ps1(min_val);
++- __m128 vmax_val = _mm_set_ps1(max_val);
+++ __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 ret;
+++ __m128 vmin_val = _mm_set_ps1(min_val);
+++ __m128 vmax_val = _mm_set_ps1(max_val);
++
++- __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
++
++- for(;number < quarterPoints; number++){
++- ret = _mm_loadu_ps(inputVectorPtr);
++- inputVectorPtr += 4;
+++ for (; number < quarterPoints; number++) {
+++ ret = _mm_loadu_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
++
++- ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
+++ ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
++
++- _mm_store_ps(outputFloatBuffer, ret);
++- for (inner_loop = 0; inner_loop < 4; inner_loop++){
++- *outputVectorPtr++ = (int8_t)(rintf(outputFloatBuffer[inner_loop]));
+++ _mm_store_ps(outputFloatBuffer, ret);
+++ for (inner_loop = 0; inner_loop < 4; inner_loop++) {
+++ *outputVectorPtr++ = (int8_t)(rintf(outputFloatBuffer[inner_loop]));
+++ }
++ }
++- }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- volk_32f_s32f_convert_8i_single(&outputVector[number], r);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ volk_32f_s32f_convert_8i_single(&outputVector[number], r);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE */
++@@ -259,18 +280,19 @@ volk_32f_s32f_convert_8i_u_sse(int8_t* outputVector, const float* inputVector,
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_s32f_convert_8i_generic(int8_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_8i_generic(int8_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- const float* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++- float r;
++-
++- for(number = 0; number < num_points; number++){
++- r = *inputVectorPtr++ * scalar;
++- volk_32f_s32f_convert_8i_single(&outputVector[number], r);
++- }
+++ const float* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++ float r;
+++
+++ for (number = 0; number < num_points; number++) {
+++ r = *inputVectorPtr++ * scalar;
+++ volk_32f_s32f_convert_8i_single(&outputVector[number], r);
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -280,68 +302,77 @@ volk_32f_s32f_convert_8i_generic(int8_t* outputVector, const float* inputVector,
++ #ifndef INCLUDED_volk_32f_s32f_convert_8i_a_H
++ #define INCLUDED_volk_32f_s32f_convert_8i_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_8i_a_avx2(int8_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_8i_a_avx2(int8_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int thirtysecondPoints = num_points / 32;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int8_t* outputVectorPtr = outputVector;
++-
++- float min_val = CHAR_MIN;
++- float max_val = CHAR_MAX;
++- float r;
++-
++- __m256 vScalar = _mm256_set1_ps(scalar);
++- __m256 inputVal1, inputVal2, inputVal3, inputVal4;
++- __m256i intInputVal1, intInputVal2, intInputVal3, intInputVal4;
++- __m256 vmin_val = _mm256_set1_ps(min_val);
++- __m256 vmax_val = _mm256_set1_ps(max_val);
++- __m256i intInputVal;
++-
++- for(;number < thirtysecondPoints; number++){
++- inputVal1 = _mm256_load_ps(inputVectorPtr); inputVectorPtr += 8;
++- inputVal2 = _mm256_load_ps(inputVectorPtr); inputVectorPtr += 8;
++- inputVal3 = _mm256_load_ps(inputVectorPtr); inputVectorPtr += 8;
++- inputVal4 = _mm256_load_ps(inputVectorPtr); inputVectorPtr += 8;
++-
++- inputVal1 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
++- inputVal2 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
++- inputVal3 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal3, vScalar), vmax_val), vmin_val);
++- inputVal4 = _mm256_max_ps(_mm256_min_ps(_mm256_mul_ps(inputVal4, vScalar), vmax_val), vmin_val);
++-
++- intInputVal1 = _mm256_cvtps_epi32(inputVal1);
++- intInputVal2 = _mm256_cvtps_epi32(inputVal2);
++- intInputVal3 = _mm256_cvtps_epi32(inputVal3);
++- intInputVal4 = _mm256_cvtps_epi32(inputVal4);
++-
++- intInputVal1 = _mm256_packs_epi32(intInputVal1, intInputVal2);
++- intInputVal1 = _mm256_permute4x64_epi64(intInputVal1, 0b11011000);
++- intInputVal3 = _mm256_packs_epi32(intInputVal3, intInputVal4);
++- intInputVal3 = _mm256_permute4x64_epi64(intInputVal3, 0b11011000);
++-
++- intInputVal1 = _mm256_packs_epi16(intInputVal1, intInputVal3);
++- intInputVal = _mm256_permute4x64_epi64(intInputVal1, 0b11011000);
++-
++- _mm256_store_si256((__m256i*)outputVectorPtr, intInputVal);
++- outputVectorPtr += 32;
++- }
++-
++- number = thirtysecondPoints * 32;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- volk_32f_s32f_convert_8i_single(&outputVector[number], r);
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int thirtysecondPoints = num_points / 32;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int8_t* outputVectorPtr = outputVector;
+++
+++ float min_val = CHAR_MIN;
+++ float max_val = CHAR_MAX;
+++ float r;
+++
+++ __m256 vScalar = _mm256_set1_ps(scalar);
+++ __m256 inputVal1, inputVal2, inputVal3, inputVal4;
+++ __m256i intInputVal1, intInputVal2, intInputVal3, intInputVal4;
+++ __m256 vmin_val = _mm256_set1_ps(min_val);
+++ __m256 vmax_val = _mm256_set1_ps(max_val);
+++ __m256i intInputVal;
+++
+++ for (; number < thirtysecondPoints; number++) {
+++ inputVal1 = _mm256_load_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++ inputVal2 = _mm256_load_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++ inputVal3 = _mm256_load_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++ inputVal4 = _mm256_load_ps(inputVectorPtr);
+++ inputVectorPtr += 8;
+++
+++ inputVal1 = _mm256_max_ps(
+++ _mm256_min_ps(_mm256_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
+++ inputVal2 = _mm256_max_ps(
+++ _mm256_min_ps(_mm256_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
+++ inputVal3 = _mm256_max_ps(
+++ _mm256_min_ps(_mm256_mul_ps(inputVal3, vScalar), vmax_val), vmin_val);
+++ inputVal4 = _mm256_max_ps(
+++ _mm256_min_ps(_mm256_mul_ps(inputVal4, vScalar), vmax_val), vmin_val);
+++
+++ intInputVal1 = _mm256_cvtps_epi32(inputVal1);
+++ intInputVal2 = _mm256_cvtps_epi32(inputVal2);
+++ intInputVal3 = _mm256_cvtps_epi32(inputVal3);
+++ intInputVal4 = _mm256_cvtps_epi32(inputVal4);
+++
+++ intInputVal1 = _mm256_packs_epi32(intInputVal1, intInputVal2);
+++ intInputVal1 = _mm256_permute4x64_epi64(intInputVal1, 0b11011000);
+++ intInputVal3 = _mm256_packs_epi32(intInputVal3, intInputVal4);
+++ intInputVal3 = _mm256_permute4x64_epi64(intInputVal3, 0b11011000);
+++
+++ intInputVal1 = _mm256_packs_epi16(intInputVal1, intInputVal3);
+++ intInputVal = _mm256_permute4x64_epi64(intInputVal1, 0b11011000);
+++
+++ _mm256_store_si256((__m256i*)outputVectorPtr, intInputVal);
+++ outputVectorPtr += 32;
+++ }
+++
+++ number = thirtysecondPoints * 32;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ volk_32f_s32f_convert_8i_single(&outputVector[number], r);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 */
++@@ -350,57 +381,66 @@ volk_32f_s32f_convert_8i_a_avx2(int8_t* outputVector, const float* inputVector,
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_8i_a_sse2(int8_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_8i_a_sse2(int8_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- const float* inputVectorPtr = (const float*)inputVector;
++- int8_t* outputVectorPtr = outputVector;
++-
++- float min_val = CHAR_MIN;
++- float max_val = CHAR_MAX;
++- float r;
++-
++- __m128 vScalar = _mm_set_ps1(scalar);
++- __m128 inputVal1, inputVal2, inputVal3, inputVal4;
++- __m128i intInputVal1, intInputVal2, intInputVal3, intInputVal4;
++- __m128 vmin_val = _mm_set_ps1(min_val);
++- __m128 vmax_val = _mm_set_ps1(max_val);
++-
++- for(;number < sixteenthPoints; number++){
++- inputVal1 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;
++- inputVal2 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;
++- inputVal3 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;
++- inputVal4 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;
++-
++- inputVal1 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
++- inputVal2 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
++- inputVal3 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal3, vScalar), vmax_val), vmin_val);
++- inputVal4 = _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal4, vScalar), vmax_val), vmin_val);
++-
++- intInputVal1 = _mm_cvtps_epi32(inputVal1);
++- intInputVal2 = _mm_cvtps_epi32(inputVal2);
++- intInputVal3 = _mm_cvtps_epi32(inputVal3);
++- intInputVal4 = _mm_cvtps_epi32(inputVal4);
++-
++- intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
++- intInputVal3 = _mm_packs_epi32(intInputVal3, intInputVal4);
++-
++- intInputVal1 = _mm_packs_epi16(intInputVal1, intInputVal3);
++-
++- _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 16;
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ const float* inputVectorPtr = (const float*)inputVector;
+++ int8_t* outputVectorPtr = outputVector;
+++
+++ float min_val = CHAR_MIN;
+++ float max_val = CHAR_MAX;
+++ float r;
+++
+++ __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 inputVal1, inputVal2, inputVal3, inputVal4;
+++ __m128i intInputVal1, intInputVal2, intInputVal3, intInputVal4;
+++ __m128 vmin_val = _mm_set_ps1(min_val);
+++ __m128 vmax_val = _mm_set_ps1(max_val);
+++
+++ for (; number < sixteenthPoints; number++) {
+++ inputVal1 = _mm_load_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++ inputVal2 = _mm_load_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++ inputVal3 = _mm_load_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++ inputVal4 = _mm_load_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
+++
+++ inputVal1 =
+++ _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal1, vScalar), vmax_val), vmin_val);
+++ inputVal2 =
+++ _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal2, vScalar), vmax_val), vmin_val);
+++ inputVal3 =
+++ _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal3, vScalar), vmax_val), vmin_val);
+++ inputVal4 =
+++ _mm_max_ps(_mm_min_ps(_mm_mul_ps(inputVal4, vScalar), vmax_val), vmin_val);
+++
+++ intInputVal1 = _mm_cvtps_epi32(inputVal1);
+++ intInputVal2 = _mm_cvtps_epi32(inputVal2);
+++ intInputVal3 = _mm_cvtps_epi32(inputVal3);
+++ intInputVal4 = _mm_cvtps_epi32(inputVal4);
+++
+++ intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
+++ intInputVal3 = _mm_packs_epi32(intInputVal3, intInputVal4);
+++
+++ intInputVal1 = _mm_packs_epi16(intInputVal1, intInputVal3);
+++
+++ _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- volk_32f_s32f_convert_8i_single(&outputVector[number], r);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ volk_32f_s32f_convert_8i_single(&outputVector[number], r);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++@@ -408,46 +448,47 @@ volk_32f_s32f_convert_8i_a_sse2(int8_t* outputVector, const float* inputVector,
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_s32f_convert_8i_a_sse(int8_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_8i_a_sse(int8_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- size_t inner_loop;
+++ unsigned int number = 0;
+++ size_t inner_loop;
++
++- const unsigned int quarterPoints = num_points / 4;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* inputVectorPtr = (const float*)inputVector;
+++ const float* inputVectorPtr = (const float*)inputVector;
++
++- float min_val = CHAR_MIN;
++- float max_val = CHAR_MAX;
++- float r;
+++ float min_val = CHAR_MIN;
+++ float max_val = CHAR_MAX;
+++ float r;
++
++- int8_t* outputVectorPtr = outputVector;
++- __m128 vScalar = _mm_set_ps1(scalar);
++- __m128 ret;
++- __m128 vmin_val = _mm_set_ps1(min_val);
++- __m128 vmax_val = _mm_set_ps1(max_val);
+++ int8_t* outputVectorPtr = outputVector;
+++ __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 ret;
+++ __m128 vmin_val = _mm_set_ps1(min_val);
+++ __m128 vmax_val = _mm_set_ps1(max_val);
++
++- __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float outputFloatBuffer[4];
++
++- for(;number < quarterPoints; number++){
++- ret = _mm_load_ps(inputVectorPtr);
++- inputVectorPtr += 4;
+++ for (; number < quarterPoints; number++) {
+++ ret = _mm_load_ps(inputVectorPtr);
+++ inputVectorPtr += 4;
++
++- ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
+++ ret = _mm_max_ps(_mm_min_ps(_mm_mul_ps(ret, vScalar), vmax_val), vmin_val);
++
++- _mm_store_ps(outputFloatBuffer, ret);
++- for (inner_loop = 0; inner_loop < 4; inner_loop++){
++- *outputVectorPtr++ = (int8_t)(rintf(outputFloatBuffer[inner_loop]));
+++ _mm_store_ps(outputFloatBuffer, ret);
+++ for (inner_loop = 0; inner_loop < 4; inner_loop++) {
+++ *outputVectorPtr++ = (int8_t)(rintf(outputFloatBuffer[inner_loop]));
+++ }
++ }
++- }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- r = inputVector[number] * scalar;
++- volk_32f_s32f_convert_8i_single(&outputVector[number], r);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ r = inputVector[number] * scalar;
+++ volk_32f_s32f_convert_8i_single(&outputVector[number], r);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE */
++@@ -455,18 +496,19 @@ volk_32f_s32f_convert_8i_a_sse(int8_t* outputVector, const float* inputVector,
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_s32f_convert_8i_a_generic(int8_t* outputVector, const float* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_convert_8i_a_generic(int8_t* outputVector,
+++ const float* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- const float* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++- float r;
++-
++- for(number = 0; number < num_points; number++){
++- r = *inputVectorPtr++ * scalar;
++- volk_32f_s32f_convert_8i_single(&outputVector[number], r);
++- }
+++ const float* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++ float r;
+++
+++ for (number = 0; number < num_points; number++) {
+++ r = *inputVectorPtr++ * scalar;
+++ volk_32f_s32f_convert_8i_single(&outputVector[number], r);
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++diff --git a/kernels/volk/volk_32f_s32f_mod_rangepuppet_32f.h b/kernels/volk/volk_32f_s32f_mod_rangepuppet_32f.h
++index 6ace77b..28d7ab5 100644
++--- a/kernels/volk/volk_32f_s32f_mod_rangepuppet_32f.h
+++++ b/kernels/volk/volk_32f_s32f_mod_rangepuppet_32f.h
++@@ -4,42 +4,77 @@
++ #include <volk/volk_32f_s32f_s32f_mod_range_32f.h>
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void volk_32f_s32f_mod_rangepuppet_32f_generic(float *output, const float *input, float bound, unsigned int num_points){
++- volk_32f_s32f_s32f_mod_range_32f_generic(output, input, bound-3.141f, bound, num_points);
+++static inline void volk_32f_s32f_mod_rangepuppet_32f_generic(float* output,
+++ const float* input,
+++ float bound,
+++ unsigned int num_points)
+++{
+++ volk_32f_s32f_s32f_mod_range_32f_generic(
+++ output, input, bound - 3.141f, bound, num_points);
++ }
++ #endif
++
++
++ #ifdef LV_HAVE_SSE
++-static inline void volk_32f_s32f_mod_rangepuppet_32f_u_sse(float *output, const float *input, float bound, unsigned int num_points){
++- volk_32f_s32f_s32f_mod_range_32f_u_sse(output, input, bound-3.141f, bound, num_points);
+++static inline void volk_32f_s32f_mod_rangepuppet_32f_u_sse(float* output,
+++ const float* input,
+++ float bound,
+++ unsigned int num_points)
+++{
+++ volk_32f_s32f_s32f_mod_range_32f_u_sse(
+++ output, input, bound - 3.141f, bound, num_points);
++ }
++ #endif
++ #ifdef LV_HAVE_SSE
++-static inline void volk_32f_s32f_mod_rangepuppet_32f_a_sse(float *output, const float *input, float bound, unsigned int num_points){
++- volk_32f_s32f_s32f_mod_range_32f_a_sse(output, input, bound-3.141f, bound, num_points);
+++static inline void volk_32f_s32f_mod_rangepuppet_32f_a_sse(float* output,
+++ const float* input,
+++ float bound,
+++ unsigned int num_points)
+++{
+++ volk_32f_s32f_s32f_mod_range_32f_a_sse(
+++ output, input, bound - 3.141f, bound, num_points);
++ }
++ #endif
++
++ #ifdef LV_HAVE_SSE2
++-static inline void volk_32f_s32f_mod_rangepuppet_32f_u_sse2(float *output, const float *input, float bound, unsigned int num_points){
++- volk_32f_s32f_s32f_mod_range_32f_u_sse2(output, input, bound-3.141f, bound, num_points);
+++static inline void volk_32f_s32f_mod_rangepuppet_32f_u_sse2(float* output,
+++ const float* input,
+++ float bound,
+++ unsigned int num_points)
+++{
+++ volk_32f_s32f_s32f_mod_range_32f_u_sse2(
+++ output, input, bound - 3.141f, bound, num_points);
++ }
++ #endif
++ #ifdef LV_HAVE_SSE2
++-static inline void volk_32f_s32f_mod_rangepuppet_32f_a_sse2(float *output, const float *input, float bound, unsigned int num_points){
++- volk_32f_s32f_s32f_mod_range_32f_a_sse2(output, input, bound-3.141f, bound, num_points);
+++static inline void volk_32f_s32f_mod_rangepuppet_32f_a_sse2(float* output,
+++ const float* input,
+++ float bound,
+++ unsigned int num_points)
+++{
+++ volk_32f_s32f_s32f_mod_range_32f_a_sse2(
+++ output, input, bound - 3.141f, bound, num_points);
++ }
++ #endif
++
++ #ifdef LV_HAVE_AVX
++-static inline void volk_32f_s32f_mod_rangepuppet_32f_u_avx(float *output, const float *input, float bound, unsigned int num_points){
++- volk_32f_s32f_s32f_mod_range_32f_u_avx(output, input, bound-3.141f, bound, num_points);
+++static inline void volk_32f_s32f_mod_rangepuppet_32f_u_avx(float* output,
+++ const float* input,
+++ float bound,
+++ unsigned int num_points)
+++{
+++ volk_32f_s32f_s32f_mod_range_32f_u_avx(
+++ output, input, bound - 3.141f, bound, num_points);
++ }
++ #endif
++ #ifdef LV_HAVE_AVX
++-static inline void volk_32f_s32f_mod_rangepuppet_32f_a_avx(float *output, const float *input, float bound, unsigned int num_points){
++- volk_32f_s32f_s32f_mod_range_32f_a_avx(output, input, bound-3.141f, bound, num_points);
+++static inline void volk_32f_s32f_mod_rangepuppet_32f_a_avx(float* output,
+++ const float* input,
+++ float bound,
+++ unsigned int num_points)
+++{
+++ volk_32f_s32f_s32f_mod_range_32f_a_avx(
+++ output, input, bound - 3.141f, bound, num_points);
++ }
++ #endif
++ #endif
++diff --git a/kernels/volk/volk_32f_s32f_multiply_32f.h b/kernels/volk/volk_32f_s32f_multiply_32f.h
++index 97c7f69..dcc9c6b 100644
++--- a/kernels/volk/volk_32f_s32f_multiply_32f.h
+++++ b/kernels/volk/volk_32f_s32f_multiply_32f.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_s32f_multiply_32f(float* cVector, const float* aVector, const float scalar, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_s32f_multiply_32f(float* cVector, const float* aVector, const float
+++ * scalar, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: The input vector of floats.
++@@ -75,84 +75,87 @@
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_s32f_multiply_32f_u_sse(float* cVector, const float* aVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_multiply_32f_u_sse(float* cVector,
+++ const float* aVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
++
++- __m128 aVal, bVal, cVal;
++- bVal = _mm_set_ps1(scalar);
++- for(;number < quarterPoints; number++){
++- aVal = _mm_loadu_ps(aPtr);
+++ __m128 aVal, bVal, cVal;
+++ bVal = _mm_set_ps1(scalar);
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_loadu_ps(aPtr);
++
++- cVal = _mm_mul_ps(aVal, bVal);
+++ cVal = _mm_mul_ps(aVal, bVal);
++
++- _mm_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) * scalar;
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * scalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_s32f_multiply_32f_u_avx(float* cVector, const float* aVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_multiply_32f_u_avx(float* cVector,
+++ const float* aVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
++
++- __m256 aVal, bVal, cVal;
++- bVal = _mm256_set1_ps(scalar);
++- for(;number < eighthPoints; number++){
+++ __m256 aVal, bVal, cVal;
+++ bVal = _mm256_set1_ps(scalar);
+++ for (; number < eighthPoints; number++) {
++
++- aVal = _mm256_loadu_ps(aPtr);
+++ aVal = _mm256_loadu_ps(aPtr);
++
++- cVal = _mm256_mul_ps(aVal, bVal);
+++ cVal = _mm256_mul_ps(aVal, bVal);
++
++- _mm256_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) * scalar;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * scalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_s32f_multiply_32f_generic(float* cVector, const float* aVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_multiply_32f_generic(float* cVector,
+++ const float* aVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const float* inputPtr = aVector;
++- float* outputPtr = cVector;
++- for(number = 0; number < num_points; number++){
++- *outputPtr = (*inputPtr) * scalar;
++- inputPtr++;
++- outputPtr++;
++- }
+++ unsigned int number = 0;
+++ const float* inputPtr = aVector;
+++ float* outputPtr = cVector;
+++ for (number = 0; number < num_points; number++) {
+++ *outputPtr = (*inputPtr) * scalar;
+++ inputPtr++;
+++ outputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -168,126 +171,132 @@ volk_32f_s32f_multiply_32f_generic(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_s32f_multiply_32f_a_sse(float* cVector, const float* aVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_multiply_32f_a_sse(float* cVector,
+++ const float* aVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
++
++- __m128 aVal, bVal, cVal;
++- bVal = _mm_set_ps1(scalar);
++- for(;number < quarterPoints; number++){
++- aVal = _mm_load_ps(aPtr);
+++ __m128 aVal, bVal, cVal;
+++ bVal = _mm_set_ps1(scalar);
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
++
++- cVal = _mm_mul_ps(aVal, bVal);
+++ cVal = _mm_mul_ps(aVal, bVal);
++
++- _mm_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) * scalar;
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * scalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_s32f_multiply_32f_a_avx(float* cVector, const float* aVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_multiply_32f_a_avx(float* cVector,
+++ const float* aVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
++
++- __m256 aVal, bVal, cVal;
++- bVal = _mm256_set1_ps(scalar);
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
+++ __m256 aVal, bVal, cVal;
+++ bVal = _mm256_set1_ps(scalar);
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
++
++- cVal = _mm256_mul_ps(aVal, bVal);
+++ cVal = _mm256_mul_ps(aVal, bVal);
++
++- _mm256_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) * scalar;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * scalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32f_s32f_multiply_32f_u_neon(float* cVector, const float* aVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_multiply_32f_u_neon(float* cVector,
+++ const float* aVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const float* inputPtr = aVector;
++- float* outputPtr = cVector;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- float32x4_t aVal, cVal;
++-
++- for(number = 0; number < quarterPoints; number++){
++- aVal = vld1q_f32(inputPtr); // Load into NEON regs
++- cVal = vmulq_n_f32 (aVal, scalar); // Do the multiply
++- vst1q_f32(outputPtr, cVal); // Store results back to output
++- inputPtr += 4;
++- outputPtr += 4;
++- }
++- for(number = quarterPoints * 4; number < num_points; number++){
++- *outputPtr++ = (*inputPtr++) * scalar;
++- }
+++ unsigned int number = 0;
+++ const float* inputPtr = aVector;
+++ float* outputPtr = cVector;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ float32x4_t aVal, cVal;
+++
+++ for (number = 0; number < quarterPoints; number++) {
+++ aVal = vld1q_f32(inputPtr); // Load into NEON regs
+++ cVal = vmulq_n_f32(aVal, scalar); // Do the multiply
+++ vst1q_f32(outputPtr, cVal); // Store results back to output
+++ inputPtr += 4;
+++ outputPtr += 4;
+++ }
+++ for (number = quarterPoints * 4; number < num_points; number++) {
+++ *outputPtr++ = (*inputPtr++) * scalar;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_s32f_multiply_32f_a_generic(float* cVector, const float* aVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_multiply_32f_a_generic(float* cVector,
+++ const float* aVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const float* inputPtr = aVector;
++- float* outputPtr = cVector;
++- for(number = 0; number < num_points; number++){
++- *outputPtr = (*inputPtr) * scalar;
++- inputPtr++;
++- outputPtr++;
++- }
+++ unsigned int number = 0;
+++ const float* inputPtr = aVector;
+++ float* outputPtr = cVector;
+++ for (number = 0; number < num_points; number++) {
+++ *outputPtr = (*inputPtr) * scalar;
+++ inputPtr++;
+++ outputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++ #ifdef LV_HAVE_ORC
++
++-extern void
++-volk_32f_s32f_multiply_32f_a_orc_impl(float* dst, const float* src,
++- const float scalar, unsigned int num_points);
+++extern void volk_32f_s32f_multiply_32f_a_orc_impl(float* dst,
+++ const float* src,
+++ const float scalar,
+++ unsigned int num_points);
++
++-static inline void
++-volk_32f_s32f_multiply_32f_u_orc(float* cVector, const float* aVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32f_s32f_multiply_32f_u_orc(float* cVector,
+++ const float* aVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- volk_32f_s32f_multiply_32f_a_orc_impl(cVector, aVector, scalar, num_points);
+++ volk_32f_s32f_multiply_32f_a_orc_impl(cVector, aVector, scalar, num_points);
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++diff --git a/kernels/volk/volk_32f_s32f_normalize.h b/kernels/volk/volk_32f_s32f_normalize.h
++index 404d534..0a05492 100644
++--- a/kernels/volk/volk_32f_s32f_normalize.h
+++++ b/kernels/volk/volk_32f_s32f_normalize.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_s32f_normalize(float* vecBuffer, const float scalar, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_s32f_normalize(float* vecBuffer, const float scalar, unsigned int
+++ * num_points) \endcode
++ *
++ * \b Inputs
++ * \li vecBuffer: The buffer of values to be vectorized.
++@@ -76,84 +76,99 @@
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32f_s32f_normalize_a_avx(float* vecBuffer, const float scalar, unsigned int num_points){
++- unsigned int number = 0;
++- float* inputPtr = vecBuffer;
+++static inline void volk_32f_s32f_normalize_a_avx(float* vecBuffer,
+++ const float scalar,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ float* inputPtr = vecBuffer;
++
++- const float invScalar = 1.0 / scalar;
++- __m256 vecScalar = _mm256_set1_ps(invScalar);
+++ const float invScalar = 1.0 / scalar;
+++ __m256 vecScalar = _mm256_set1_ps(invScalar);
++
++- __m256 input1;
+++ __m256 input1;
++
++- const uint64_t eighthPoints = num_points / 8;
++- for(;number < eighthPoints; number++){
+++ const uint64_t eighthPoints = num_points / 8;
+++ for (; number < eighthPoints; number++) {
++
++- input1 = _mm256_load_ps(inputPtr);
+++ input1 = _mm256_load_ps(inputPtr);
++
++- input1 = _mm256_mul_ps(input1, vecScalar);
+++ input1 = _mm256_mul_ps(input1, vecScalar);
++
++- _mm256_store_ps(inputPtr, input1);
+++ _mm256_store_ps(inputPtr, input1);
++
++- inputPtr += 8;
++- }
+++ inputPtr += 8;
+++ }
++
++- number = eighthPoints*8;
++- for(; number < num_points; number++){
++- *inputPtr *= invScalar;
++- inputPtr++;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *inputPtr *= invScalar;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void volk_32f_s32f_normalize_a_sse(float* vecBuffer, const float scalar, unsigned int num_points){
++- unsigned int number = 0;
++- float* inputPtr = vecBuffer;
+++static inline void volk_32f_s32f_normalize_a_sse(float* vecBuffer,
+++ const float scalar,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ float* inputPtr = vecBuffer;
++
++- const float invScalar = 1.0 / scalar;
++- __m128 vecScalar = _mm_set_ps1(invScalar);
+++ const float invScalar = 1.0 / scalar;
+++ __m128 vecScalar = _mm_set_ps1(invScalar);
++
++- __m128 input1;
+++ __m128 input1;
++
++- const uint64_t quarterPoints = num_points / 4;
++- for(;number < quarterPoints; number++){
+++ const uint64_t quarterPoints = num_points / 4;
+++ for (; number < quarterPoints; number++) {
++
++- input1 = _mm_load_ps(inputPtr);
+++ input1 = _mm_load_ps(inputPtr);
++
++- input1 = _mm_mul_ps(input1, vecScalar);
+++ input1 = _mm_mul_ps(input1, vecScalar);
++
++- _mm_store_ps(inputPtr, input1);
+++ _mm_store_ps(inputPtr, input1);
++
++- inputPtr += 4;
++- }
+++ inputPtr += 4;
+++ }
++
++- number = quarterPoints*4;
++- for(; number < num_points; number++){
++- *inputPtr *= invScalar;
++- inputPtr++;
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *inputPtr *= invScalar;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32f_s32f_normalize_generic(float* vecBuffer, const float scalar, unsigned int num_points){
++- unsigned int number = 0;
++- float* inputPtr = vecBuffer;
++- const float invScalar = 1.0 / scalar;
++- for(number = 0; number < num_points; number++){
++- *inputPtr *= invScalar;
++- inputPtr++;
++- }
+++static inline void volk_32f_s32f_normalize_generic(float* vecBuffer,
+++ const float scalar,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ float* inputPtr = vecBuffer;
+++ const float invScalar = 1.0 / scalar;
+++ for (number = 0; number < num_points; number++) {
+++ *inputPtr *= invScalar;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_ORC
++
++-extern void volk_32f_s32f_normalize_a_orc_impl(float* dst, float* src, const float scalar, unsigned int num_points);
++-static inline void volk_32f_s32f_normalize_u_orc(float* vecBuffer, const float scalar, unsigned int num_points){
+++extern void volk_32f_s32f_normalize_a_orc_impl(float* dst,
+++ float* src,
+++ const float scalar,
+++ unsigned int num_points);
+++static inline void volk_32f_s32f_normalize_u_orc(float* vecBuffer,
+++ const float scalar,
+++ unsigned int num_points)
+++{
++ float invscalar = 1.0 / scalar;
++ volk_32f_s32f_normalize_a_orc_impl(vecBuffer, vecBuffer, invscalar, num_points);
++ }
++@@ -169,32 +184,35 @@ static inline void volk_32f_s32f_normalize_u_orc(float* vecBuffer, const float s
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32f_s32f_normalize_u_avx(float* vecBuffer, const float scalar, unsigned int num_points){
++- unsigned int number = 0;
++- float* inputPtr = vecBuffer;
+++static inline void volk_32f_s32f_normalize_u_avx(float* vecBuffer,
+++ const float scalar,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ float* inputPtr = vecBuffer;
++
++- const float invScalar = 1.0 / scalar;
++- __m256 vecScalar = _mm256_set1_ps(invScalar);
+++ const float invScalar = 1.0 / scalar;
+++ __m256 vecScalar = _mm256_set1_ps(invScalar);
++
++- __m256 input1;
+++ __m256 input1;
++
++- const uint64_t eighthPoints = num_points / 8;
++- for(;number < eighthPoints; number++){
+++ const uint64_t eighthPoints = num_points / 8;
+++ for (; number < eighthPoints; number++) {
++
++- input1 = _mm256_loadu_ps(inputPtr);
+++ input1 = _mm256_loadu_ps(inputPtr);
++
++- input1 = _mm256_mul_ps(input1, vecScalar);
+++ input1 = _mm256_mul_ps(input1, vecScalar);
++
++- _mm256_storeu_ps(inputPtr, input1);
+++ _mm256_storeu_ps(inputPtr, input1);
++
++- inputPtr += 8;
++- }
+++ inputPtr += 8;
+++ }
++
++- number = eighthPoints*8;
++- for(; number < num_points; number++){
++- *inputPtr *= invScalar;
++- inputPtr++;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *inputPtr *= invScalar;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++diff --git a/kernels/volk/volk_32f_s32f_power_32f.h b/kernels/volk/volk_32f_s32f_power_32f.h
++index 070efdc..9b6fdf4 100644
++--- a/kernels/volk/volk_32f_s32f_power_32f.h
+++++ b/kernels/volk/volk_32f_s32f_power_32f.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_s32f_power_32f(float* cVector, const float* aVector, const float power, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_s32f_power_32f(float* cVector, const float* aVector, const float power,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: The input vector of floats.
++@@ -72,8 +72,8 @@
++ #define INCLUDED_volk_32f_s32f_power_32f_a_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_SSE4_1
++ #include <tmmintrin.h>
++@@ -82,49 +82,51 @@
++ #include <simdmath.h>
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++
++-static inline void
++-volk_32f_s32f_power_32f_a_sse4_1(float* cVector, const float* aVector,
++- const float power, unsigned int num_points)
+++static inline void volk_32f_s32f_power_32f_a_sse4_1(float* cVector,
+++ const float* aVector,
+++ const float power,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
+++ unsigned int number = 0;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
++
++ #ifdef LV_HAVE_LIB_SIMDMATH
++- const unsigned int quarterPoints = num_points / 4;
++- __m128 vPower = _mm_set_ps1(power);
++- __m128 zeroValue = _mm_setzero_ps();
++- __m128 signMask;
++- __m128 negatedValues;
++- __m128 negativeOneToPower = _mm_set_ps1(powf(-1, power));
++- __m128 onesMask = _mm_set_ps1(1);
+++ const unsigned int quarterPoints = num_points / 4;
+++ __m128 vPower = _mm_set_ps1(power);
+++ __m128 zeroValue = _mm_setzero_ps();
+++ __m128 signMask;
+++ __m128 negatedValues;
+++ __m128 negativeOneToPower = _mm_set_ps1(powf(-1, power));
+++ __m128 onesMask = _mm_set_ps1(1);
++
++- __m128 aVal, cVal;
++- for(;number < quarterPoints; number++){
+++ __m128 aVal, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm_load_ps(aPtr);
++- signMask = _mm_cmplt_ps(aVal, zeroValue);
++- negatedValues = _mm_sub_ps(zeroValue, aVal);
++- aVal = _mm_blendv_ps(aVal, negatedValues, signMask);
+++ aVal = _mm_load_ps(aPtr);
+++ signMask = _mm_cmplt_ps(aVal, zeroValue);
+++ negatedValues = _mm_sub_ps(zeroValue, aVal);
+++ aVal = _mm_blendv_ps(aVal, negatedValues, signMask);
++
++- // powf4 doesn't support negative values in the base, so we mask them off and then apply the negative after
++- cVal = powf4(aVal, vPower); // Takes each input value to the specified power
+++ // powf4 doesn't support negative values in the base, so we mask them off and then
+++ // apply the negative after
+++ cVal = powf4(aVal, vPower); // Takes each input value to the specified power
++
++- cVal = _mm_mul_ps( _mm_blendv_ps(onesMask, negativeOneToPower, signMask), cVal);
+++ cVal = _mm_mul_ps(_mm_blendv_ps(onesMask, negativeOneToPower, signMask), cVal);
++
++- _mm_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
+++ number = quarterPoints * 4;
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++
++- for(;number < num_points; number++){
++- *cPtr++ = powf((*aPtr++), power);
++- }
+++ for (; number < num_points; number++) {
+++ *cPtr++ = powf((*aPtr++), power);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 */
++@@ -137,49 +139,54 @@ volk_32f_s32f_power_32f_a_sse4_1(float* cVector, const float* aVector,
++ #include <simdmath.h>
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++
++-static inline void
++-volk_32f_s32f_power_32f_a_sse(float* cVector, const float* aVector,
++- const float power, unsigned int num_points)
+++static inline void volk_32f_s32f_power_32f_a_sse(float* cVector,
+++ const float* aVector,
+++ const float power,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
+++ unsigned int number = 0;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
++
++ #ifdef LV_HAVE_LIB_SIMDMATH
++- const unsigned int quarterPoints = num_points / 4;
++- __m128 vPower = _mm_set_ps1(power);
++- __m128 zeroValue = _mm_setzero_ps();
++- __m128 signMask;
++- __m128 negatedValues;
++- __m128 negativeOneToPower = _mm_set_ps1(powf(-1, power));
++- __m128 onesMask = _mm_set_ps1(1);
++-
++- __m128 aVal, cVal;
++- for(;number < quarterPoints; number++){
++-
++- aVal = _mm_load_ps(aPtr);
++- signMask = _mm_cmplt_ps(aVal, zeroValue);
++- negatedValues = _mm_sub_ps(zeroValue, aVal);
++- aVal = _mm_or_ps(_mm_andnot_ps(signMask, aVal), _mm_and_ps(signMask, negatedValues) );
++-
++- // powf4 doesn't support negative values in the base, so we mask them off and then apply the negative after
++- cVal = powf4(aVal, vPower); // Takes each input value to the specified power
++-
++- cVal = _mm_mul_ps( _mm_or_ps( _mm_andnot_ps(signMask, onesMask), _mm_and_ps(signMask, negativeOneToPower) ), cVal);
++-
++- _mm_store_ps(cPtr,cVal); // Store the results back into the C container
++-
++- aPtr += 4;
++- cPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
+++ const unsigned int quarterPoints = num_points / 4;
+++ __m128 vPower = _mm_set_ps1(power);
+++ __m128 zeroValue = _mm_setzero_ps();
+++ __m128 signMask;
+++ __m128 negatedValues;
+++ __m128 negativeOneToPower = _mm_set_ps1(powf(-1, power));
+++ __m128 onesMask = _mm_set_ps1(1);
+++
+++ __m128 aVal, cVal;
+++ for (; number < quarterPoints; number++) {
+++
+++ aVal = _mm_load_ps(aPtr);
+++ signMask = _mm_cmplt_ps(aVal, zeroValue);
+++ negatedValues = _mm_sub_ps(zeroValue, aVal);
+++ aVal =
+++ _mm_or_ps(_mm_andnot_ps(signMask, aVal), _mm_and_ps(signMask, negatedValues));
+++
+++ // powf4 doesn't support negative values in the base, so we mask them off and then
+++ // apply the negative after
+++ cVal = powf4(aVal, vPower); // Takes each input value to the specified power
+++
+++ cVal = _mm_mul_ps(_mm_or_ps(_mm_andnot_ps(signMask, onesMask),
+++ _mm_and_ps(signMask, negativeOneToPower)),
+++ cVal);
+++
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
+++
+++ aPtr += 4;
+++ cPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++
++- for(;number < num_points; number++){
++- *cPtr++ = powf((*aPtr++), power);
++- }
+++ for (; number < num_points; number++) {
+++ *cPtr++ = powf((*aPtr++), power);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE */
++@@ -187,17 +194,18 @@ volk_32f_s32f_power_32f_a_sse(float* cVector, const float* aVector,
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_s32f_power_32f_generic(float* cVector, const float* aVector,
++- const float power, unsigned int num_points)
+++static inline void volk_32f_s32f_power_32f_generic(float* cVector,
+++ const float* aVector,
+++ const float power,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = powf((*aPtr++), power);
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = powf((*aPtr++), power);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32f_s32f_s32f_mod_range_32f.h b/kernels/volk/volk_32f_s32f_s32f_mod_range_32f.h
++index 53b4937..d7f23fe 100644
++--- a/kernels/volk/volk_32f_s32f_s32f_mod_range_32f.h
+++++ b/kernels/volk/volk_32f_s32f_s32f_mod_range_32f.h
++@@ -25,8 +25,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_s32f_s32f_mod_range_32f(float* outputVector, const float* inputVector, const float lower_bound, const float upper_bound, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_s32f_s32f_mod_range_32f(float* outputVector, const float* inputVector,
+++ * const float lower_bound, const float upper_bound, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li inputVector: The input vector
++@@ -46,117 +46,129 @@
++ #ifdef LV_HAVE_AVX
++ #include <xmmintrin.h>
++
++-static inline void volk_32f_s32f_s32f_mod_range_32f_u_avx(float* outputVector, const float* inputVector, const float lower_bound, const float upper_bound, unsigned int num_points){
++- __m256 lower = _mm256_set1_ps(lower_bound);
++- __m256 upper = _mm256_set1_ps(upper_bound);
++- __m256 distance = _mm256_sub_ps(upper,lower);
++- float dist = upper_bound - lower_bound;
++- __m256 input, output;
++- __m256 is_smaller, is_bigger;
++- __m256 excess, adj;
++-
++- const float *inPtr = inputVector;
++- float *outPtr = outputVector;
++- size_t eight_points = num_points / 8;
++- size_t counter;
++- for(counter = 0; counter < eight_points; counter++) {
++- input = _mm256_loadu_ps(inPtr);
++- // calculate mask: input < lower, input > upper
++- is_smaller = _mm256_cmp_ps(input, lower, _CMP_LT_OQ); //0x11: Less than, ordered, non-signalling
++- is_bigger = _mm256_cmp_ps(input, upper, _CMP_GT_OQ); //0x1e: greater than, ordered, non-signalling
++- // find out how far we are out-of-bound – positive values!
++- excess = _mm256_and_ps(_mm256_sub_ps(lower, input), is_smaller);
++- excess = _mm256_or_ps(_mm256_and_ps(_mm256_sub_ps(input, upper), is_bigger), excess);
++- // how many do we have to add? (int(excess/distance+1)*distance)
++- excess = _mm256_div_ps(excess, distance);
++- // round down
++- excess = _mm256_cvtepi32_ps(_mm256_cvttps_epi32(excess));
++- // plus 1
++- adj = _mm256_set1_ps(1.0f);
++- excess = _mm256_add_ps(excess, adj);
++- // get the sign right, adj is still {1.0f,1.0f,1.0f,1.0f}
++- adj = _mm256_and_ps(adj, is_smaller);
++- adj = _mm256_or_ps(_mm256_and_ps(_mm256_set1_ps(-1.0f), is_bigger), adj);
++- // scale by distance, sign
++- excess = _mm256_mul_ps(_mm256_mul_ps(excess, adj), distance);
++- output = _mm256_add_ps(input, excess);
++- _mm256_storeu_ps(outPtr, output);
++- inPtr += 8;
++- outPtr += 8;
++- }
++-
++- size_t cnt;
++- for(cnt = eight_points * 8; cnt < num_points; cnt++){
++- float val = inputVector[cnt];
++- if(val < lower_bound){
++- float excess = lower_bound - val;
++- signed int count = (int)(excess/dist);
++- outputVector[cnt] = val + (count+1)*dist;
+++static inline void volk_32f_s32f_s32f_mod_range_32f_u_avx(float* outputVector,
+++ const float* inputVector,
+++ const float lower_bound,
+++ const float upper_bound,
+++ unsigned int num_points)
+++{
+++ __m256 lower = _mm256_set1_ps(lower_bound);
+++ __m256 upper = _mm256_set1_ps(upper_bound);
+++ __m256 distance = _mm256_sub_ps(upper, lower);
+++ float dist = upper_bound - lower_bound;
+++ __m256 input, output;
+++ __m256 is_smaller, is_bigger;
+++ __m256 excess, adj;
+++
+++ const float* inPtr = inputVector;
+++ float* outPtr = outputVector;
+++ size_t eight_points = num_points / 8;
+++ size_t counter;
+++ for (counter = 0; counter < eight_points; counter++) {
+++ input = _mm256_loadu_ps(inPtr);
+++ // calculate mask: input < lower, input > upper
+++ is_smaller = _mm256_cmp_ps(
+++ input, lower, _CMP_LT_OQ); // 0x11: Less than, ordered, non-signalling
+++ is_bigger = _mm256_cmp_ps(
+++ input, upper, _CMP_GT_OQ); // 0x1e: greater than, ordered, non-signalling
+++ // find out how far we are out-of-bound – positive values!
+++ excess = _mm256_and_ps(_mm256_sub_ps(lower, input), is_smaller);
+++ excess =
+++ _mm256_or_ps(_mm256_and_ps(_mm256_sub_ps(input, upper), is_bigger), excess);
+++ // how many do we have to add? (int(excess/distance+1)*distance)
+++ excess = _mm256_div_ps(excess, distance);
+++ // round down
+++ excess = _mm256_cvtepi32_ps(_mm256_cvttps_epi32(excess));
+++ // plus 1
+++ adj = _mm256_set1_ps(1.0f);
+++ excess = _mm256_add_ps(excess, adj);
+++ // get the sign right, adj is still {1.0f,1.0f,1.0f,1.0f}
+++ adj = _mm256_and_ps(adj, is_smaller);
+++ adj = _mm256_or_ps(_mm256_and_ps(_mm256_set1_ps(-1.0f), is_bigger), adj);
+++ // scale by distance, sign
+++ excess = _mm256_mul_ps(_mm256_mul_ps(excess, adj), distance);
+++ output = _mm256_add_ps(input, excess);
+++ _mm256_storeu_ps(outPtr, output);
+++ inPtr += 8;
+++ outPtr += 8;
++ }
++- else if(val > upper_bound){
++- float excess = val - upper_bound;
++- signed int count = (int)(excess/dist);
++- outputVector[cnt] = val - (count+1)*dist;
+++
+++ size_t cnt;
+++ for (cnt = eight_points * 8; cnt < num_points; cnt++) {
+++ float val = inputVector[cnt];
+++ if (val < lower_bound) {
+++ float excess = lower_bound - val;
+++ signed int count = (int)(excess / dist);
+++ outputVector[cnt] = val + (count + 1) * dist;
+++ } else if (val > upper_bound) {
+++ float excess = val - upper_bound;
+++ signed int count = (int)(excess / dist);
+++ outputVector[cnt] = val - (count + 1) * dist;
+++ } else
+++ outputVector[cnt] = val;
++ }
++- else
++- outputVector[cnt] = val;
++- }
++ }
++-static inline void volk_32f_s32f_s32f_mod_range_32f_a_avx(float* outputVector, const float* inputVector, const float lower_bound, const float upper_bound, unsigned int num_points){
++- __m256 lower = _mm256_set1_ps(lower_bound);
++- __m256 upper = _mm256_set1_ps(upper_bound);
++- __m256 distance = _mm256_sub_ps(upper,lower);
++- float dist = upper_bound - lower_bound;
++- __m256 input, output;
++- __m256 is_smaller, is_bigger;
++- __m256 excess, adj;
++-
++- const float *inPtr = inputVector;
++- float *outPtr = outputVector;
++- size_t eight_points = num_points / 8;
++- size_t counter;
++- for(counter = 0; counter < eight_points; counter++) {
++- input = _mm256_load_ps(inPtr);
++- // calculate mask: input < lower, input > upper
++- is_smaller = _mm256_cmp_ps(input, lower, _CMP_LT_OQ); //0x11: Less than, ordered, non-signalling
++- is_bigger = _mm256_cmp_ps(input, upper, _CMP_GT_OQ); //0x1e: greater than, ordered, non-signalling
++- // find out how far we are out-of-bound – positive values!
++- excess = _mm256_and_ps(_mm256_sub_ps(lower, input), is_smaller);
++- excess = _mm256_or_ps(_mm256_and_ps(_mm256_sub_ps(input, upper), is_bigger), excess);
++- // how many do we have to add? (int(excess/distance+1)*distance)
++- excess = _mm256_div_ps(excess, distance);
++- // round down
++- excess = _mm256_cvtepi32_ps(_mm256_cvttps_epi32(excess));
++- // plus 1
++- adj = _mm256_set1_ps(1.0f);
++- excess = _mm256_add_ps(excess, adj);
++- // get the sign right, adj is still {1.0f,1.0f,1.0f,1.0f}
++- adj = _mm256_and_ps(adj, is_smaller);
++- adj = _mm256_or_ps(_mm256_and_ps(_mm256_set1_ps(-1.0f), is_bigger), adj);
++- // scale by distance, sign
++- excess = _mm256_mul_ps(_mm256_mul_ps(excess, adj), distance);
++- output = _mm256_add_ps(input, excess);
++- _mm256_store_ps(outPtr, output);
++- inPtr += 8;
++- outPtr += 8;
++- }
++-
++- size_t cnt;
++- for(cnt = eight_points * 8; cnt < num_points; cnt++){
++- float val = inputVector[cnt];
++- if(val < lower_bound){
++- float excess = lower_bound - val;
++- signed int count = (int)(excess/dist);
++- outputVector[cnt] = val + (count+1)*dist;
+++static inline void volk_32f_s32f_s32f_mod_range_32f_a_avx(float* outputVector,
+++ const float* inputVector,
+++ const float lower_bound,
+++ const float upper_bound,
+++ unsigned int num_points)
+++{
+++ __m256 lower = _mm256_set1_ps(lower_bound);
+++ __m256 upper = _mm256_set1_ps(upper_bound);
+++ __m256 distance = _mm256_sub_ps(upper, lower);
+++ float dist = upper_bound - lower_bound;
+++ __m256 input, output;
+++ __m256 is_smaller, is_bigger;
+++ __m256 excess, adj;
+++
+++ const float* inPtr = inputVector;
+++ float* outPtr = outputVector;
+++ size_t eight_points = num_points / 8;
+++ size_t counter;
+++ for (counter = 0; counter < eight_points; counter++) {
+++ input = _mm256_load_ps(inPtr);
+++ // calculate mask: input < lower, input > upper
+++ is_smaller = _mm256_cmp_ps(
+++ input, lower, _CMP_LT_OQ); // 0x11: Less than, ordered, non-signalling
+++ is_bigger = _mm256_cmp_ps(
+++ input, upper, _CMP_GT_OQ); // 0x1e: greater than, ordered, non-signalling
+++ // find out how far we are out-of-bound – positive values!
+++ excess = _mm256_and_ps(_mm256_sub_ps(lower, input), is_smaller);
+++ excess =
+++ _mm256_or_ps(_mm256_and_ps(_mm256_sub_ps(input, upper), is_bigger), excess);
+++ // how many do we have to add? (int(excess/distance+1)*distance)
+++ excess = _mm256_div_ps(excess, distance);
+++ // round down
+++ excess = _mm256_cvtepi32_ps(_mm256_cvttps_epi32(excess));
+++ // plus 1
+++ adj = _mm256_set1_ps(1.0f);
+++ excess = _mm256_add_ps(excess, adj);
+++ // get the sign right, adj is still {1.0f,1.0f,1.0f,1.0f}
+++ adj = _mm256_and_ps(adj, is_smaller);
+++ adj = _mm256_or_ps(_mm256_and_ps(_mm256_set1_ps(-1.0f), is_bigger), adj);
+++ // scale by distance, sign
+++ excess = _mm256_mul_ps(_mm256_mul_ps(excess, adj), distance);
+++ output = _mm256_add_ps(input, excess);
+++ _mm256_store_ps(outPtr, output);
+++ inPtr += 8;
+++ outPtr += 8;
++ }
++- else if(val > upper_bound){
++- float excess = val - upper_bound;
++- signed int count = (int)(excess/dist);
++- outputVector[cnt] = val - (count+1)*dist;
+++
+++ size_t cnt;
+++ for (cnt = eight_points * 8; cnt < num_points; cnt++) {
+++ float val = inputVector[cnt];
+++ if (val < lower_bound) {
+++ float excess = lower_bound - val;
+++ signed int count = (int)(excess / dist);
+++ outputVector[cnt] = val + (count + 1) * dist;
+++ } else if (val > upper_bound) {
+++ float excess = val - upper_bound;
+++ signed int count = (int)(excess / dist);
+++ outputVector[cnt] = val - (count + 1) * dist;
+++ } else
+++ outputVector[cnt] = val;
++ }
++- else
++- outputVector[cnt] = val;
++- }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -164,268 +176,282 @@ static inline void volk_32f_s32f_s32f_mod_range_32f_a_avx(float* outputVector, c
++ #ifdef LV_HAVE_SSE2
++ #include <xmmintrin.h>
++
++-static inline void volk_32f_s32f_s32f_mod_range_32f_u_sse2(float* outputVector, const float* inputVector, const float lower_bound, const float upper_bound, unsigned int num_points){
++- __m128 lower = _mm_set_ps1(lower_bound);
++- __m128 upper = _mm_set_ps1(upper_bound);
++- __m128 distance = _mm_sub_ps(upper,lower);
++- float dist = upper_bound - lower_bound;
++- __m128 input, output;
++- __m128 is_smaller, is_bigger;
++- __m128 excess, adj;
++-
++- const float *inPtr = inputVector;
++- float *outPtr = outputVector;
++- size_t quarter_points = num_points / 4;
++- size_t counter;
++- for(counter = 0; counter < quarter_points; counter++) {
++- input = _mm_load_ps(inPtr);
++- // calculate mask: input < lower, input > upper
++- is_smaller = _mm_cmplt_ps(input, lower);
++- is_bigger = _mm_cmpgt_ps(input, upper);
++- // find out how far we are out-of-bound – positive values!
++- excess = _mm_and_ps(_mm_sub_ps(lower, input), is_smaller);
++- excess = _mm_or_ps(_mm_and_ps(_mm_sub_ps(input, upper), is_bigger), excess);
++- // how many do we have to add? (int(excess/distance+1)*distance)
++- excess = _mm_div_ps(excess, distance);
++- // round down
++- excess = _mm_cvtepi32_ps(_mm_cvttps_epi32(excess));
++- // plus 1
++- adj = _mm_set_ps1(1.0f);
++- excess = _mm_add_ps(excess, adj);
++- // get the sign right, adj is still {1.0f,1.0f,1.0f,1.0f}
++- adj = _mm_and_ps(adj, is_smaller);
++- adj = _mm_or_ps(_mm_and_ps(_mm_set_ps1(-1.0f), is_bigger), adj);
++- // scale by distance, sign
++- excess = _mm_mul_ps(_mm_mul_ps(excess, adj), distance);
++- output = _mm_add_ps(input, excess);
++- _mm_store_ps(outPtr, output);
++- inPtr += 4;
++- outPtr += 4;
++- }
++-
++- size_t cnt;
++- for(cnt = quarter_points * 4; cnt < num_points; cnt++){
++- float val = inputVector[cnt];
++- if(val < lower_bound){
++- float excess = lower_bound - val;
++- signed int count = (int)(excess/dist);
++- outputVector[cnt] = val + (count+1)*dist;
+++static inline void volk_32f_s32f_s32f_mod_range_32f_u_sse2(float* outputVector,
+++ const float* inputVector,
+++ const float lower_bound,
+++ const float upper_bound,
+++ unsigned int num_points)
+++{
+++ __m128 lower = _mm_set_ps1(lower_bound);
+++ __m128 upper = _mm_set_ps1(upper_bound);
+++ __m128 distance = _mm_sub_ps(upper, lower);
+++ float dist = upper_bound - lower_bound;
+++ __m128 input, output;
+++ __m128 is_smaller, is_bigger;
+++ __m128 excess, adj;
+++
+++ const float* inPtr = inputVector;
+++ float* outPtr = outputVector;
+++ size_t quarter_points = num_points / 4;
+++ size_t counter;
+++ for (counter = 0; counter < quarter_points; counter++) {
+++ input = _mm_load_ps(inPtr);
+++ // calculate mask: input < lower, input > upper
+++ is_smaller = _mm_cmplt_ps(input, lower);
+++ is_bigger = _mm_cmpgt_ps(input, upper);
+++ // find out how far we are out-of-bound – positive values!
+++ excess = _mm_and_ps(_mm_sub_ps(lower, input), is_smaller);
+++ excess = _mm_or_ps(_mm_and_ps(_mm_sub_ps(input, upper), is_bigger), excess);
+++ // how many do we have to add? (int(excess/distance+1)*distance)
+++ excess = _mm_div_ps(excess, distance);
+++ // round down
+++ excess = _mm_cvtepi32_ps(_mm_cvttps_epi32(excess));
+++ // plus 1
+++ adj = _mm_set_ps1(1.0f);
+++ excess = _mm_add_ps(excess, adj);
+++ // get the sign right, adj is still {1.0f,1.0f,1.0f,1.0f}
+++ adj = _mm_and_ps(adj, is_smaller);
+++ adj = _mm_or_ps(_mm_and_ps(_mm_set_ps1(-1.0f), is_bigger), adj);
+++ // scale by distance, sign
+++ excess = _mm_mul_ps(_mm_mul_ps(excess, adj), distance);
+++ output = _mm_add_ps(input, excess);
+++ _mm_store_ps(outPtr, output);
+++ inPtr += 4;
+++ outPtr += 4;
++ }
++- else if(val > upper_bound){
++- float excess = val - upper_bound;
++- signed int count = (int)(excess/dist);
++- outputVector[cnt] = val - (count+1)*dist;
+++
+++ size_t cnt;
+++ for (cnt = quarter_points * 4; cnt < num_points; cnt++) {
+++ float val = inputVector[cnt];
+++ if (val < lower_bound) {
+++ float excess = lower_bound - val;
+++ signed int count = (int)(excess / dist);
+++ outputVector[cnt] = val + (count + 1) * dist;
+++ } else if (val > upper_bound) {
+++ float excess = val - upper_bound;
+++ signed int count = (int)(excess / dist);
+++ outputVector[cnt] = val - (count + 1) * dist;
+++ } else
+++ outputVector[cnt] = val;
++ }
++- else
++- outputVector[cnt] = val;
++- }
++ }
++-static inline void volk_32f_s32f_s32f_mod_range_32f_a_sse2(float* outputVector, const float* inputVector, const float lower_bound, const float upper_bound, unsigned int num_points){
++- __m128 lower = _mm_set_ps1(lower_bound);
++- __m128 upper = _mm_set_ps1(upper_bound);
++- __m128 distance = _mm_sub_ps(upper,lower);
++- __m128 input, output;
++- __m128 is_smaller, is_bigger;
++- __m128 excess, adj;
++-
++- const float *inPtr = inputVector;
++- float *outPtr = outputVector;
++- size_t quarter_points = num_points / 4;
++- size_t counter;
++- for(counter = 0; counter < quarter_points; counter++) {
++- input = _mm_load_ps(inPtr);
++- // calculate mask: input < lower, input > upper
++- is_smaller = _mm_cmplt_ps(input, lower);
++- is_bigger = _mm_cmpgt_ps(input, upper);
++- // find out how far we are out-of-bound – positive values!
++- excess = _mm_and_ps(_mm_sub_ps(lower, input), is_smaller);
++- excess = _mm_or_ps(_mm_and_ps(_mm_sub_ps(input, upper), is_bigger), excess);
++- // how many do we have to add? (int(excess/distance+1)*distance)
++- excess = _mm_div_ps(excess, distance);
++- // round down – for some reason, SSE doesn't come with a 4x float -> 4x int32 conversion.
++- excess = _mm_cvtepi32_ps(_mm_cvttps_epi32(excess));
++- // plus 1
++- adj = _mm_set_ps1(1.0f);
++- excess = _mm_add_ps(excess, adj);
++- // get the sign right, adj is still {1.0f,1.0f,1.0f,1.0f}
++- adj = _mm_and_ps(adj, is_smaller);
++- adj = _mm_or_ps(_mm_and_ps(_mm_set_ps1(-1.0f), is_bigger), adj);
++- // scale by distance, sign
++- excess = _mm_mul_ps(_mm_mul_ps(excess, adj), distance);
++- output = _mm_add_ps(input, excess);
++- _mm_store_ps(outPtr, output);
++- inPtr += 4;
++- outPtr += 4;
++- }
++-
++- float dist = upper_bound - lower_bound;
++- size_t cnt;
++- for(cnt = quarter_points * 4; cnt < num_points; cnt++){
++- float val = inputVector[cnt];
++- if(val < lower_bound){
++- float excess = lower_bound - val;
++- signed int count = (int)(excess/dist);
++- outputVector[cnt] = val + (count+1)*dist;
+++static inline void volk_32f_s32f_s32f_mod_range_32f_a_sse2(float* outputVector,
+++ const float* inputVector,
+++ const float lower_bound,
+++ const float upper_bound,
+++ unsigned int num_points)
+++{
+++ __m128 lower = _mm_set_ps1(lower_bound);
+++ __m128 upper = _mm_set_ps1(upper_bound);
+++ __m128 distance = _mm_sub_ps(upper, lower);
+++ __m128 input, output;
+++ __m128 is_smaller, is_bigger;
+++ __m128 excess, adj;
+++
+++ const float* inPtr = inputVector;
+++ float* outPtr = outputVector;
+++ size_t quarter_points = num_points / 4;
+++ size_t counter;
+++ for (counter = 0; counter < quarter_points; counter++) {
+++ input = _mm_load_ps(inPtr);
+++ // calculate mask: input < lower, input > upper
+++ is_smaller = _mm_cmplt_ps(input, lower);
+++ is_bigger = _mm_cmpgt_ps(input, upper);
+++ // find out how far we are out-of-bound – positive values!
+++ excess = _mm_and_ps(_mm_sub_ps(lower, input), is_smaller);
+++ excess = _mm_or_ps(_mm_and_ps(_mm_sub_ps(input, upper), is_bigger), excess);
+++ // how many do we have to add? (int(excess/distance+1)*distance)
+++ excess = _mm_div_ps(excess, distance);
+++ // round down – for some reason, SSE doesn't come with a 4x float -> 4x int32
+++ // conversion.
+++ excess = _mm_cvtepi32_ps(_mm_cvttps_epi32(excess));
+++ // plus 1
+++ adj = _mm_set_ps1(1.0f);
+++ excess = _mm_add_ps(excess, adj);
+++ // get the sign right, adj is still {1.0f,1.0f,1.0f,1.0f}
+++ adj = _mm_and_ps(adj, is_smaller);
+++ adj = _mm_or_ps(_mm_and_ps(_mm_set_ps1(-1.0f), is_bigger), adj);
+++ // scale by distance, sign
+++ excess = _mm_mul_ps(_mm_mul_ps(excess, adj), distance);
+++ output = _mm_add_ps(input, excess);
+++ _mm_store_ps(outPtr, output);
+++ inPtr += 4;
+++ outPtr += 4;
++ }
++- else if(val > upper_bound){
++- float excess = val - upper_bound;
++- signed int count = (int)(excess/dist);
++- outputVector[cnt] = val - (count+1)*dist;
+++
+++ float dist = upper_bound - lower_bound;
+++ size_t cnt;
+++ for (cnt = quarter_points * 4; cnt < num_points; cnt++) {
+++ float val = inputVector[cnt];
+++ if (val < lower_bound) {
+++ float excess = lower_bound - val;
+++ signed int count = (int)(excess / dist);
+++ outputVector[cnt] = val + (count + 1) * dist;
+++ } else if (val > upper_bound) {
+++ float excess = val - upper_bound;
+++ signed int count = (int)(excess / dist);
+++ outputVector[cnt] = val - (count + 1) * dist;
+++ } else
+++ outputVector[cnt] = val;
++ }
++- else
++- outputVector[cnt] = val;
++- }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void volk_32f_s32f_s32f_mod_range_32f_u_sse(float* outputVector, const float* inputVector, const float lower_bound, const float upper_bound, unsigned int num_points){
++- __m128 lower = _mm_set_ps1(lower_bound);
++- __m128 upper = _mm_set_ps1(upper_bound);
++- __m128 distance = _mm_sub_ps(upper,lower);
++- float dist = upper_bound - lower_bound;
++- __m128 input, output;
++- __m128 is_smaller, is_bigger;
++- __m128 excess, adj;
++- __m128i rounddown;
++-
++- const float *inPtr = inputVector;
++- float *outPtr = outputVector;
++- size_t quarter_points = num_points / 4;
++- size_t counter;
++- for(counter = 0; counter < quarter_points; counter++) {
++- input = _mm_load_ps(inPtr);
++- // calculate mask: input < lower, input > upper
++- is_smaller = _mm_cmplt_ps(input, lower);
++- is_bigger = _mm_cmpgt_ps(input, upper);
++- // find out how far we are out-of-bound – positive values!
++- excess = _mm_and_ps(_mm_sub_ps(lower, input), is_smaller);
++- excess = _mm_or_ps(_mm_and_ps(_mm_sub_ps(input, upper), is_bigger), excess);
++- // how many do we have to add? (int(excess/distance+1)*distance)
++- excess = _mm_div_ps(excess, distance);
++- // round down – for some reason
++- rounddown = _mm_cvttps_epi32(excess);
++- excess = _mm_cvtepi32_ps(rounddown);
++- // plus 1
++- adj = _mm_set_ps1(1.0f);
++- excess = _mm_add_ps(excess, adj);
++- // get the sign right, adj is still {1.0f,1.0f,1.0f,1.0f}
++- adj = _mm_and_ps(adj, is_smaller);
++- adj = _mm_or_ps(_mm_and_ps(_mm_set_ps1(-1.0f), is_bigger), adj);
++- // scale by distance, sign
++- excess = _mm_mul_ps(_mm_mul_ps(excess, adj), distance);
++- output = _mm_add_ps(input, excess);
++- _mm_store_ps(outPtr, output);
++- inPtr += 4;
++- outPtr += 4;
++- }
++-
++- size_t cnt;
++- for(cnt = quarter_points * 4; cnt < num_points; cnt++){
++- float val = inputVector[cnt];
++- if(val < lower_bound){
++- float excess = lower_bound - val;
++- signed int count = (int)(excess/dist);
++- outputVector[cnt] = val + (count+1)*dist;
+++static inline void volk_32f_s32f_s32f_mod_range_32f_u_sse(float* outputVector,
+++ const float* inputVector,
+++ const float lower_bound,
+++ const float upper_bound,
+++ unsigned int num_points)
+++{
+++ __m128 lower = _mm_set_ps1(lower_bound);
+++ __m128 upper = _mm_set_ps1(upper_bound);
+++ __m128 distance = _mm_sub_ps(upper, lower);
+++ float dist = upper_bound - lower_bound;
+++ __m128 input, output;
+++ __m128 is_smaller, is_bigger;
+++ __m128 excess, adj;
+++ __m128i rounddown;
+++
+++ const float* inPtr = inputVector;
+++ float* outPtr = outputVector;
+++ size_t quarter_points = num_points / 4;
+++ size_t counter;
+++ for (counter = 0; counter < quarter_points; counter++) {
+++ input = _mm_load_ps(inPtr);
+++ // calculate mask: input < lower, input > upper
+++ is_smaller = _mm_cmplt_ps(input, lower);
+++ is_bigger = _mm_cmpgt_ps(input, upper);
+++ // find out how far we are out-of-bound – positive values!
+++ excess = _mm_and_ps(_mm_sub_ps(lower, input), is_smaller);
+++ excess = _mm_or_ps(_mm_and_ps(_mm_sub_ps(input, upper), is_bigger), excess);
+++ // how many do we have to add? (int(excess/distance+1)*distance)
+++ excess = _mm_div_ps(excess, distance);
+++ // round down – for some reason
+++ rounddown = _mm_cvttps_epi32(excess);
+++ excess = _mm_cvtepi32_ps(rounddown);
+++ // plus 1
+++ adj = _mm_set_ps1(1.0f);
+++ excess = _mm_add_ps(excess, adj);
+++ // get the sign right, adj is still {1.0f,1.0f,1.0f,1.0f}
+++ adj = _mm_and_ps(adj, is_smaller);
+++ adj = _mm_or_ps(_mm_and_ps(_mm_set_ps1(-1.0f), is_bigger), adj);
+++ // scale by distance, sign
+++ excess = _mm_mul_ps(_mm_mul_ps(excess, adj), distance);
+++ output = _mm_add_ps(input, excess);
+++ _mm_store_ps(outPtr, output);
+++ inPtr += 4;
+++ outPtr += 4;
++ }
++- else if(val > upper_bound){
++- float excess = val - upper_bound;
++- signed int count = (int)(excess/dist);
++- outputVector[cnt] = val - (count+1)*dist;
+++
+++ size_t cnt;
+++ for (cnt = quarter_points * 4; cnt < num_points; cnt++) {
+++ float val = inputVector[cnt];
+++ if (val < lower_bound) {
+++ float excess = lower_bound - val;
+++ signed int count = (int)(excess / dist);
+++ outputVector[cnt] = val + (count + 1) * dist;
+++ } else if (val > upper_bound) {
+++ float excess = val - upper_bound;
+++ signed int count = (int)(excess / dist);
+++ outputVector[cnt] = val - (count + 1) * dist;
+++ } else
+++ outputVector[cnt] = val;
++ }
++- else
++- outputVector[cnt] = val;
++- }
++ }
++-static inline void volk_32f_s32f_s32f_mod_range_32f_a_sse(float* outputVector, const float* inputVector, const float lower_bound, const float upper_bound, unsigned int num_points){
++- __m128 lower = _mm_set_ps1(lower_bound);
++- __m128 upper = _mm_set_ps1(upper_bound);
++- __m128 distance = _mm_sub_ps(upper,lower);
++- __m128 input, output;
++- __m128 is_smaller, is_bigger;
++- __m128 excess, adj;
++- __m128i rounddown;
++-
++- const float *inPtr = inputVector;
++- float *outPtr = outputVector;
++- size_t quarter_points = num_points / 4;
++- size_t counter;
++- for(counter = 0; counter < quarter_points; counter++) {
++- input = _mm_load_ps(inPtr);
++- // calculate mask: input < lower, input > upper
++- is_smaller = _mm_cmplt_ps(input, lower);
++- is_bigger = _mm_cmpgt_ps(input, upper);
++- // find out how far we are out-of-bound – positive values!
++- excess = _mm_and_ps(_mm_sub_ps(lower, input), is_smaller);
++- excess = _mm_or_ps(_mm_and_ps(_mm_sub_ps(input, upper), is_bigger), excess);
++- // how many do we have to add? (int(excess/distance+1)*distance)
++- excess = _mm_div_ps(excess, distance);
++- // round down
++- rounddown = _mm_cvttps_epi32(excess);
++- excess = _mm_cvtepi32_ps(rounddown);
++- // plus 1
++- adj = _mm_set_ps1(1.0f);
++- excess = _mm_add_ps(excess, adj);
++- // get the sign right, adj is still {1.0f,1.0f,1.0f,1.0f}
++- adj = _mm_and_ps(adj, is_smaller);
++- adj = _mm_or_ps(_mm_and_ps(_mm_set_ps1(-1.0f), is_bigger), adj);
++- // scale by distance, sign
++- excess = _mm_mul_ps(_mm_mul_ps(excess, adj), distance);
++- output = _mm_add_ps(input, excess);
++- _mm_store_ps(outPtr, output);
++- inPtr += 4;
++- outPtr += 4;
++- }
++-
++- float dist = upper_bound - lower_bound;
++- size_t cnt;
++- for(cnt = quarter_points * 4; cnt < num_points; cnt++){
++- float val = inputVector[cnt];
++- if(val < lower_bound){
++- float excess = lower_bound - val;
++- signed int count = (int)(excess/dist);
++- outputVector[cnt] = val + (count+1)*dist;
+++static inline void volk_32f_s32f_s32f_mod_range_32f_a_sse(float* outputVector,
+++ const float* inputVector,
+++ const float lower_bound,
+++ const float upper_bound,
+++ unsigned int num_points)
+++{
+++ __m128 lower = _mm_set_ps1(lower_bound);
+++ __m128 upper = _mm_set_ps1(upper_bound);
+++ __m128 distance = _mm_sub_ps(upper, lower);
+++ __m128 input, output;
+++ __m128 is_smaller, is_bigger;
+++ __m128 excess, adj;
+++ __m128i rounddown;
+++
+++ const float* inPtr = inputVector;
+++ float* outPtr = outputVector;
+++ size_t quarter_points = num_points / 4;
+++ size_t counter;
+++ for (counter = 0; counter < quarter_points; counter++) {
+++ input = _mm_load_ps(inPtr);
+++ // calculate mask: input < lower, input > upper
+++ is_smaller = _mm_cmplt_ps(input, lower);
+++ is_bigger = _mm_cmpgt_ps(input, upper);
+++ // find out how far we are out-of-bound – positive values!
+++ excess = _mm_and_ps(_mm_sub_ps(lower, input), is_smaller);
+++ excess = _mm_or_ps(_mm_and_ps(_mm_sub_ps(input, upper), is_bigger), excess);
+++ // how many do we have to add? (int(excess/distance+1)*distance)
+++ excess = _mm_div_ps(excess, distance);
+++ // round down
+++ rounddown = _mm_cvttps_epi32(excess);
+++ excess = _mm_cvtepi32_ps(rounddown);
+++ // plus 1
+++ adj = _mm_set_ps1(1.0f);
+++ excess = _mm_add_ps(excess, adj);
+++ // get the sign right, adj is still {1.0f,1.0f,1.0f,1.0f}
+++ adj = _mm_and_ps(adj, is_smaller);
+++ adj = _mm_or_ps(_mm_and_ps(_mm_set_ps1(-1.0f), is_bigger), adj);
+++ // scale by distance, sign
+++ excess = _mm_mul_ps(_mm_mul_ps(excess, adj), distance);
+++ output = _mm_add_ps(input, excess);
+++ _mm_store_ps(outPtr, output);
+++ inPtr += 4;
+++ outPtr += 4;
++ }
++- else if(val > upper_bound){
++- float excess = val - upper_bound;
++- signed int count = (int)(excess/dist);
++- outputVector[cnt] = val - (count+1)*dist;
+++
+++ float dist = upper_bound - lower_bound;
+++ size_t cnt;
+++ for (cnt = quarter_points * 4; cnt < num_points; cnt++) {
+++ float val = inputVector[cnt];
+++ if (val < lower_bound) {
+++ float excess = lower_bound - val;
+++ signed int count = (int)(excess / dist);
+++ outputVector[cnt] = val + (count + 1) * dist;
+++ } else if (val > upper_bound) {
+++ float excess = val - upper_bound;
+++ signed int count = (int)(excess / dist);
+++ outputVector[cnt] = val - (count + 1) * dist;
+++ } else
+++ outputVector[cnt] = val;
++ }
++- else
++- outputVector[cnt] = val;
++- }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32f_s32f_s32f_mod_range_32f_generic(float* outputVector, const float* inputVector, const float lower_bound, const float upper_bound, unsigned int num_points){
++- float* outPtr = outputVector;
++- const float *inPtr;
++- float distance = upper_bound - lower_bound;
++-
++- for(inPtr = inputVector; inPtr < inputVector + num_points; inPtr++){
++- float val = *inPtr;
++- if(val < lower_bound){
++- float excess = lower_bound - val;
++- signed int count = (int)(excess/distance);
++- *outPtr = val + (count+1)*distance;
++- }
++- else if(val > upper_bound){
++- float excess = val - upper_bound;
++- signed int count = (int)(excess/distance);
++- *outPtr = val - (count+1)*distance;
+++static inline void volk_32f_s32f_s32f_mod_range_32f_generic(float* outputVector,
+++ const float* inputVector,
+++ const float lower_bound,
+++ const float upper_bound,
+++ unsigned int num_points)
+++{
+++ float* outPtr = outputVector;
+++ const float* inPtr;
+++ float distance = upper_bound - lower_bound;
+++
+++ for (inPtr = inputVector; inPtr < inputVector + num_points; inPtr++) {
+++ float val = *inPtr;
+++ if (val < lower_bound) {
+++ float excess = lower_bound - val;
+++ signed int count = (int)(excess / distance);
+++ *outPtr = val + (count + 1) * distance;
+++ } else if (val > upper_bound) {
+++ float excess = val - upper_bound;
+++ signed int count = (int)(excess / distance);
+++ *outPtr = val - (count + 1) * distance;
+++ } else
+++ *outPtr = val;
+++ outPtr++;
++ }
++- else
++- *outPtr = val;
++- outPtr++;
++- }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++-
++ #endif /* INCLUDED_VOLK_32F_S32F_S32F_MOD_RANGE_32F_A_H */
++diff --git a/kernels/volk/volk_32f_s32f_stddev_32f.h b/kernels/volk/volk_32f_s32f_stddev_32f.h
++index 4f3dc1c..0a1c32b 100644
++--- a/kernels/volk/volk_32f_s32f_stddev_32f.h
+++++ b/kernels/volk/volk_32f_s32f_stddev_32f.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_s32f_stddev_32f(float* stddev, const float* inputBuffer, const float mean, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_s32f_stddev_32f(float* stddev, const float* inputBuffer, const float
+++ * mean, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li inputBuffer: The input vector of floats.
++@@ -68,65 +68,72 @@
++ #ifndef INCLUDED_volk_32f_s32f_stddev_32f_a_H
++ #define INCLUDED_volk_32f_s32f_stddev_32f_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void
++-volk_32f_s32f_stddev_32f_a_sse4_1(float* stddev, const float* inputBuffer,
++- const float mean, unsigned int num_points)
+++static inline void volk_32f_s32f_stddev_32f_a_sse4_1(float* stddev,
+++ const float* inputBuffer,
+++ const float mean,
+++ unsigned int num_points)
++ {
++- float returnValue = 0;
++- if(num_points > 0){
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- const float* aPtr = inputBuffer;
++-
++- __VOLK_ATTR_ALIGNED(16) float squareBuffer[4];
++-
++- __m128 squareAccumulator = _mm_setzero_ps();
++- __m128 aVal1, aVal2, aVal3, aVal4;
++- __m128 cVal1, cVal2, cVal3, cVal4;
++- for(;number < sixteenthPoints; number++) {
++- aVal1 = _mm_load_ps(aPtr); aPtr += 4;
++- cVal1 = _mm_dp_ps(aVal1, aVal1, 0xF1);
++-
++- aVal2 = _mm_load_ps(aPtr); aPtr += 4;
++- cVal2 = _mm_dp_ps(aVal2, aVal2, 0xF2);
++-
++- aVal3 = _mm_load_ps(aPtr); aPtr += 4;
++- cVal3 = _mm_dp_ps(aVal3, aVal3, 0xF4);
++-
++- aVal4 = _mm_load_ps(aPtr); aPtr += 4;
++- cVal4 = _mm_dp_ps(aVal4, aVal4, 0xF8);
++-
++- cVal1 = _mm_or_ps(cVal1, cVal2);
++- cVal3 = _mm_or_ps(cVal3, cVal4);
++- cVal1 = _mm_or_ps(cVal1, cVal3);
++-
++- squareAccumulator = _mm_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2
+++ float returnValue = 0;
+++ if (num_points > 0) {
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ const float* aPtr = inputBuffer;
+++
+++ __VOLK_ATTR_ALIGNED(16) float squareBuffer[4];
+++
+++ __m128 squareAccumulator = _mm_setzero_ps();
+++ __m128 aVal1, aVal2, aVal3, aVal4;
+++ __m128 cVal1, cVal2, cVal3, cVal4;
+++ for (; number < sixteenthPoints; number++) {
+++ aVal1 = _mm_load_ps(aPtr);
+++ aPtr += 4;
+++ cVal1 = _mm_dp_ps(aVal1, aVal1, 0xF1);
+++
+++ aVal2 = _mm_load_ps(aPtr);
+++ aPtr += 4;
+++ cVal2 = _mm_dp_ps(aVal2, aVal2, 0xF2);
+++
+++ aVal3 = _mm_load_ps(aPtr);
+++ aPtr += 4;
+++ cVal3 = _mm_dp_ps(aVal3, aVal3, 0xF4);
+++
+++ aVal4 = _mm_load_ps(aPtr);
+++ aPtr += 4;
+++ cVal4 = _mm_dp_ps(aVal4, aVal4, 0xF8);
+++
+++ cVal1 = _mm_or_ps(cVal1, cVal2);
+++ cVal3 = _mm_or_ps(cVal3, cVal4);
+++ cVal1 = _mm_or_ps(cVal1, cVal3);
+++
+++ squareAccumulator =
+++ _mm_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2
+++ }
+++ _mm_store_ps(squareBuffer,
+++ squareAccumulator); // Store the results back into the C container
+++ returnValue = squareBuffer[0];
+++ returnValue += squareBuffer[1];
+++ returnValue += squareBuffer[2];
+++ returnValue += squareBuffer[3];
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ returnValue += (*aPtr) * (*aPtr);
+++ aPtr++;
+++ }
+++ returnValue /= num_points;
+++ returnValue -= (mean * mean);
+++ returnValue = sqrtf(returnValue);
++ }
++- _mm_store_ps(squareBuffer,squareAccumulator); // Store the results back into the C container
++- returnValue = squareBuffer[0];
++- returnValue += squareBuffer[1];
++- returnValue += squareBuffer[2];
++- returnValue += squareBuffer[3];
++-
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- returnValue += (*aPtr) * (*aPtr);
++- aPtr++;
++- }
++- returnValue /= num_points;
++- returnValue -= (mean * mean);
++- returnValue = sqrtf(returnValue);
++- }
++- *stddev = returnValue;
+++ *stddev = returnValue;
++ }
++
++ #endif /* LV_HAVE_SSE4_1 */
++@@ -134,43 +141,45 @@ volk_32f_s32f_stddev_32f_a_sse4_1(float* stddev, const float* inputBuffer,
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_s32f_stddev_32f_a_sse(float* stddev, const float* inputBuffer,
++- const float mean, unsigned int num_points)
+++static inline void volk_32f_s32f_stddev_32f_a_sse(float* stddev,
+++ const float* inputBuffer,
+++ const float mean,
+++ unsigned int num_points)
++ {
++- float returnValue = 0;
++- if(num_points > 0){
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* aPtr = inputBuffer;
++-
++- __VOLK_ATTR_ALIGNED(16) float squareBuffer[4];
++-
++- __m128 squareAccumulator = _mm_setzero_ps();
++- __m128 aVal = _mm_setzero_ps();
++- for(;number < quarterPoints; number++) {
++- aVal = _mm_load_ps(aPtr); // aVal = x
++- aVal = _mm_mul_ps(aVal, aVal); // squareAccumulator += x^2
++- squareAccumulator = _mm_add_ps(squareAccumulator, aVal);
++- aPtr += 4;
++- }
++- _mm_store_ps(squareBuffer,squareAccumulator); // Store the results back into the C container
++- returnValue = squareBuffer[0];
++- returnValue += squareBuffer[1];
++- returnValue += squareBuffer[2];
++- returnValue += squareBuffer[3];
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- returnValue += (*aPtr) * (*aPtr);
++- aPtr++;
+++ float returnValue = 0;
+++ if (num_points > 0) {
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* aPtr = inputBuffer;
+++
+++ __VOLK_ATTR_ALIGNED(16) float squareBuffer[4];
+++
+++ __m128 squareAccumulator = _mm_setzero_ps();
+++ __m128 aVal = _mm_setzero_ps();
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr); // aVal = x
+++ aVal = _mm_mul_ps(aVal, aVal); // squareAccumulator += x^2
+++ squareAccumulator = _mm_add_ps(squareAccumulator, aVal);
+++ aPtr += 4;
+++ }
+++ _mm_store_ps(squareBuffer,
+++ squareAccumulator); // Store the results back into the C container
+++ returnValue = squareBuffer[0];
+++ returnValue += squareBuffer[1];
+++ returnValue += squareBuffer[2];
+++ returnValue += squareBuffer[3];
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ returnValue += (*aPtr) * (*aPtr);
+++ aPtr++;
+++ }
+++ returnValue /= num_points;
+++ returnValue -= (mean * mean);
+++ returnValue = sqrtf(returnValue);
++ }
++- returnValue /= num_points;
++- returnValue -= (mean * mean);
++- returnValue = sqrtf(returnValue);
++- }
++- *stddev = returnValue;
+++ *stddev = returnValue;
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -178,86 +187,93 @@ volk_32f_s32f_stddev_32f_a_sse(float* stddev, const float* inputBuffer,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_s32f_stddev_32f_a_avx(float* stddev, const float* inputBuffer,
++- const float mean, unsigned int num_points)
+++static inline void volk_32f_s32f_stddev_32f_a_avx(float* stddev,
+++ const float* inputBuffer,
+++ const float mean,
+++ unsigned int num_points)
++ {
++- float stdDev = 0;
++- if(num_points > 0){
++- unsigned int number = 0;
++- const unsigned int thirtySecondthPoints = num_points / 32;
++-
++- const float* aPtr = inputBuffer;
++- __VOLK_ATTR_ALIGNED(32) float squareBuffer[8];
++-
++- __m256 squareAccumulator = _mm256_setzero_ps();
++- __m256 aVal1, aVal2, aVal3, aVal4;
++- __m256 cVal1, cVal2, cVal3, cVal4;
++- for(;number < thirtySecondthPoints; number++) {
++- aVal1 = _mm256_load_ps(aPtr); aPtr += 8;
++- cVal1 = _mm256_dp_ps(aVal1, aVal1, 0xF1);
++-
++- aVal2 = _mm256_load_ps(aPtr); aPtr += 8;
++- cVal2 = _mm256_dp_ps(aVal2, aVal2, 0xF2);
++-
++- aVal3 = _mm256_load_ps(aPtr); aPtr += 8;
++- cVal3 = _mm256_dp_ps(aVal3, aVal3, 0xF4);
++-
++- aVal4 = _mm256_load_ps(aPtr); aPtr += 8;
++- cVal4 = _mm256_dp_ps(aVal4, aVal4, 0xF8);
++-
++- cVal1 = _mm256_or_ps(cVal1, cVal2);
++- cVal3 = _mm256_or_ps(cVal3, cVal4);
++- cVal1 = _mm256_or_ps(cVal1, cVal3);
++-
++- squareAccumulator = _mm256_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2
+++ float stdDev = 0;
+++ if (num_points > 0) {
+++ unsigned int number = 0;
+++ const unsigned int thirtySecondthPoints = num_points / 32;
+++
+++ const float* aPtr = inputBuffer;
+++ __VOLK_ATTR_ALIGNED(32) float squareBuffer[8];
+++
+++ __m256 squareAccumulator = _mm256_setzero_ps();
+++ __m256 aVal1, aVal2, aVal3, aVal4;
+++ __m256 cVal1, cVal2, cVal3, cVal4;
+++ for (; number < thirtySecondthPoints; number++) {
+++ aVal1 = _mm256_load_ps(aPtr);
+++ aPtr += 8;
+++ cVal1 = _mm256_dp_ps(aVal1, aVal1, 0xF1);
+++
+++ aVal2 = _mm256_load_ps(aPtr);
+++ aPtr += 8;
+++ cVal2 = _mm256_dp_ps(aVal2, aVal2, 0xF2);
+++
+++ aVal3 = _mm256_load_ps(aPtr);
+++ aPtr += 8;
+++ cVal3 = _mm256_dp_ps(aVal3, aVal3, 0xF4);
+++
+++ aVal4 = _mm256_load_ps(aPtr);
+++ aPtr += 8;
+++ cVal4 = _mm256_dp_ps(aVal4, aVal4, 0xF8);
+++
+++ cVal1 = _mm256_or_ps(cVal1, cVal2);
+++ cVal3 = _mm256_or_ps(cVal3, cVal4);
+++ cVal1 = _mm256_or_ps(cVal1, cVal3);
+++
+++ squareAccumulator =
+++ _mm256_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2
+++ }
+++ _mm256_store_ps(squareBuffer,
+++ squareAccumulator); // Store the results back into the C container
+++ stdDev = squareBuffer[0];
+++ stdDev += squareBuffer[1];
+++ stdDev += squareBuffer[2];
+++ stdDev += squareBuffer[3];
+++ stdDev += squareBuffer[4];
+++ stdDev += squareBuffer[5];
+++ stdDev += squareBuffer[6];
+++ stdDev += squareBuffer[7];
+++
+++ number = thirtySecondthPoints * 32;
+++ for (; number < num_points; number++) {
+++ stdDev += (*aPtr) * (*aPtr);
+++ aPtr++;
+++ }
+++ stdDev /= num_points;
+++ stdDev -= (mean * mean);
+++ stdDev = sqrtf(stdDev);
++ }
++- _mm256_store_ps(squareBuffer,squareAccumulator); // Store the results back into the C container
++- stdDev = squareBuffer[0];
++- stdDev += squareBuffer[1];
++- stdDev += squareBuffer[2];
++- stdDev += squareBuffer[3];
++- stdDev += squareBuffer[4];
++- stdDev += squareBuffer[5];
++- stdDev += squareBuffer[6];
++- stdDev += squareBuffer[7];
++-
++- number = thirtySecondthPoints * 32;
++- for(;number < num_points; number++){
++- stdDev += (*aPtr) * (*aPtr);
++- aPtr++;
++- }
++- stdDev /= num_points;
++- stdDev -= (mean * mean);
++- stdDev = sqrtf(stdDev);
++- }
++- *stddev = stdDev;
++-
+++ *stddev = stdDev;
++ }
++ #endif /* LV_HAVE_AVX */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_s32f_stddev_32f_generic(float* stddev, const float* inputBuffer,
++- const float mean, unsigned int num_points)
+++static inline void volk_32f_s32f_stddev_32f_generic(float* stddev,
+++ const float* inputBuffer,
+++ const float mean,
+++ unsigned int num_points)
++ {
++- float returnValue = 0;
++- if(num_points > 0){
++- const float* aPtr = inputBuffer;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- returnValue += (*aPtr) * (*aPtr);
++- aPtr++;
+++ float returnValue = 0;
+++ if (num_points > 0) {
+++ const float* aPtr = inputBuffer;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ returnValue += (*aPtr) * (*aPtr);
+++ aPtr++;
+++ }
+++
+++ returnValue /= num_points;
+++ returnValue -= (mean * mean);
+++ returnValue = sqrtf(returnValue);
++ }
++-
++- returnValue /= num_points;
++- returnValue -= (mean * mean);
++- returnValue = sqrtf(returnValue);
++- }
++- *stddev = returnValue;
+++ *stddev = returnValue;
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -268,69 +284,76 @@ volk_32f_s32f_stddev_32f_generic(float* stddev, const float* inputBuffer,
++ #ifndef INCLUDED_volk_32f_s32f_stddev_32f_u_H
++ #define INCLUDED_volk_32f_s32f_stddev_32f_u_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_s32f_stddev_32f_u_avx(float* stddev, const float* inputBuffer,
++- const float mean, unsigned int num_points)
+++static inline void volk_32f_s32f_stddev_32f_u_avx(float* stddev,
+++ const float* inputBuffer,
+++ const float mean,
+++ unsigned int num_points)
++ {
++- float stdDev = 0;
++- if(num_points > 0){
++- unsigned int number = 0;
++- const unsigned int thirtySecondthPoints = num_points / 32;
++-
++- const float* aPtr = inputBuffer;
++- __VOLK_ATTR_ALIGNED(32) float squareBuffer[8];
++-
++- __m256 squareAccumulator = _mm256_setzero_ps();
++- __m256 aVal1, aVal2, aVal3, aVal4;
++- __m256 cVal1, cVal2, cVal3, cVal4;
++- for(;number < thirtySecondthPoints; number++) {
++- aVal1 = _mm256_loadu_ps(aPtr); aPtr += 8;
++- cVal1 = _mm256_dp_ps(aVal1, aVal1, 0xF1);
++-
++- aVal2 = _mm256_loadu_ps(aPtr); aPtr += 8;
++- cVal2 = _mm256_dp_ps(aVal2, aVal2, 0xF2);
++-
++- aVal3 = _mm256_loadu_ps(aPtr); aPtr += 8;
++- cVal3 = _mm256_dp_ps(aVal3, aVal3, 0xF4);
++-
++- aVal4 = _mm256_loadu_ps(aPtr); aPtr += 8;
++- cVal4 = _mm256_dp_ps(aVal4, aVal4, 0xF8);
++-
++- cVal1 = _mm256_or_ps(cVal1, cVal2);
++- cVal3 = _mm256_or_ps(cVal3, cVal4);
++- cVal1 = _mm256_or_ps(cVal1, cVal3);
++-
++- squareAccumulator = _mm256_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2
+++ float stdDev = 0;
+++ if (num_points > 0) {
+++ unsigned int number = 0;
+++ const unsigned int thirtySecondthPoints = num_points / 32;
+++
+++ const float* aPtr = inputBuffer;
+++ __VOLK_ATTR_ALIGNED(32) float squareBuffer[8];
+++
+++ __m256 squareAccumulator = _mm256_setzero_ps();
+++ __m256 aVal1, aVal2, aVal3, aVal4;
+++ __m256 cVal1, cVal2, cVal3, cVal4;
+++ for (; number < thirtySecondthPoints; number++) {
+++ aVal1 = _mm256_loadu_ps(aPtr);
+++ aPtr += 8;
+++ cVal1 = _mm256_dp_ps(aVal1, aVal1, 0xF1);
+++
+++ aVal2 = _mm256_loadu_ps(aPtr);
+++ aPtr += 8;
+++ cVal2 = _mm256_dp_ps(aVal2, aVal2, 0xF2);
+++
+++ aVal3 = _mm256_loadu_ps(aPtr);
+++ aPtr += 8;
+++ cVal3 = _mm256_dp_ps(aVal3, aVal3, 0xF4);
+++
+++ aVal4 = _mm256_loadu_ps(aPtr);
+++ aPtr += 8;
+++ cVal4 = _mm256_dp_ps(aVal4, aVal4, 0xF8);
+++
+++ cVal1 = _mm256_or_ps(cVal1, cVal2);
+++ cVal3 = _mm256_or_ps(cVal3, cVal4);
+++ cVal1 = _mm256_or_ps(cVal1, cVal3);
+++
+++ squareAccumulator =
+++ _mm256_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2
+++ }
+++ _mm256_storeu_ps(
+++ squareBuffer,
+++ squareAccumulator); // Store the results back into the C container
+++ stdDev = squareBuffer[0];
+++ stdDev += squareBuffer[1];
+++ stdDev += squareBuffer[2];
+++ stdDev += squareBuffer[3];
+++ stdDev += squareBuffer[4];
+++ stdDev += squareBuffer[5];
+++ stdDev += squareBuffer[6];
+++ stdDev += squareBuffer[7];
+++
+++ number = thirtySecondthPoints * 32;
+++ for (; number < num_points; number++) {
+++ stdDev += (*aPtr) * (*aPtr);
+++ aPtr++;
+++ }
+++ stdDev /= num_points;
+++ stdDev -= (mean * mean);
+++ stdDev = sqrtf(stdDev);
++ }
++- _mm256_storeu_ps(squareBuffer,squareAccumulator); // Store the results back into the C container
++- stdDev = squareBuffer[0];
++- stdDev += squareBuffer[1];
++- stdDev += squareBuffer[2];
++- stdDev += squareBuffer[3];
++- stdDev += squareBuffer[4];
++- stdDev += squareBuffer[5];
++- stdDev += squareBuffer[6];
++- stdDev += squareBuffer[7];
++-
++- number = thirtySecondthPoints * 32;
++- for(;number < num_points; number++){
++- stdDev += (*aPtr) * (*aPtr);
++- aPtr++;
++- }
++- stdDev /= num_points;
++- stdDev -= (mean * mean);
++- stdDev = sqrtf(stdDev);
++- }
++- *stddev = stdDev;
++-
+++ *stddev = stdDev;
++ }
++ #endif /* LV_HAVE_AVX */
++
++diff --git a/kernels/volk/volk_32f_sin_32f.h b/kernels/volk/volk_32f_sin_32f.h
++index 3780086..e65f25a 100644
++--- a/kernels/volk/volk_32f_sin_32f.h
+++++ b/kernels/volk/volk_32f_sin_32f.h
++@@ -69,9 +69,9 @@
++ * \endcode
++ */
++
++-#include <stdio.h>
++-#include <math.h>
++ #include <inttypes.h>
+++#include <math.h>
+++#include <stdio.h>
++
++ #ifndef INCLUDED_volk_32f_sin_32f_a_H
++ #define INCLUDED_volk_32f_sin_32f_a_H
++@@ -83,72 +83,93 @@
++ static inline void
++ volk_32f_sin_32f_a_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- unsigned int i = 0;
++-
++- __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m256 sine, cosine, condition1, condition2;
++- __m256i q, r, ones, twos, fours;
++-
++- m4pi = _mm256_set1_ps(1.273239545);
++- pio4A = _mm256_set1_ps(0.78515625);
++- pio4B = _mm256_set1_ps(0.241876e-3);
++- ffours = _mm256_set1_ps(4.0);
++- ftwos = _mm256_set1_ps(2.0);
++- fones = _mm256_set1_ps(1.0);
++- fzeroes = _mm256_setzero_ps();
++- ones = _mm256_set1_epi32(1);
++- twos = _mm256_set1_epi32(2);
++- fours = _mm256_set1_epi32(4);
++-
++- cp1 = _mm256_set1_ps(1.0);
++- cp2 = _mm256_set1_ps(0.83333333e-1);
++- cp3 = _mm256_set1_ps(0.2777778e-2);
++- cp4 = _mm256_set1_ps(0.49603e-4);
++- cp5 = _mm256_set1_ps(0.551e-6);
++-
++- for(;number < eighthPoints; number++) {
++- aVal = _mm256_load_ps(aPtr);
++- s = _mm256_sub_ps(aVal, _mm256_and_ps(_mm256_mul_ps(aVal, ftwos), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
++- q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
++- r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
++-
++- s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4A, s);
++- s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4B, s);
++-
++- s = _mm256_div_ps(s, _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm256_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm256_mul_ps(_mm256_fmadd_ps(_mm256_fmsub_ps(_mm256_fmadd_ps(_mm256_fmsub_ps(s, cp5, cp4), s, cp3), s, cp2), s, cp1), s);
++-
++- for(i = 0; i < 3; i++) {
++- s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ unsigned int i = 0;
+++
+++ __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones,
+++ fzeroes;
+++ __m256 sine, cosine, condition1, condition2;
+++ __m256i q, r, ones, twos, fours;
+++
+++ m4pi = _mm256_set1_ps(1.273239545);
+++ pio4A = _mm256_set1_ps(0.78515625);
+++ pio4B = _mm256_set1_ps(0.241876e-3);
+++ ffours = _mm256_set1_ps(4.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ fones = _mm256_set1_ps(1.0);
+++ fzeroes = _mm256_setzero_ps();
+++ ones = _mm256_set1_epi32(1);
+++ twos = _mm256_set1_epi32(2);
+++ fours = _mm256_set1_epi32(4);
+++
+++ cp1 = _mm256_set1_ps(1.0);
+++ cp2 = _mm256_set1_ps(0.83333333e-1);
+++ cp3 = _mm256_set1_ps(0.2777778e-2);
+++ cp4 = _mm256_set1_ps(0.49603e-4);
+++ cp5 = _mm256_set1_ps(0.551e-6);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ s = _mm256_sub_ps(aVal,
+++ _mm256_and_ps(_mm256_mul_ps(aVal, ftwos),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
+++ q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
+++ r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
+++
+++ s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4A, s);
+++ s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4B, s);
+++
+++ s = _mm256_div_ps(
+++ s,
+++ _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm256_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm256_mul_ps(
+++ _mm256_fmadd_ps(
+++ _mm256_fmsub_ps(
+++ _mm256_fmadd_ps(_mm256_fmsub_ps(s, cp5, cp4), s, cp3), s, cp2),
+++ s,
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++) {
+++ s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ }
+++ s = _mm256_div_ps(s, ftwos);
+++
+++ sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
+++ cosine = _mm256_sub_ps(fones, s);
+++
+++ condition1 = _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)),
+++ fzeroes,
+++ _CMP_NEQ_UQ);
+++ condition2 = _mm256_cmp_ps(
+++ _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS),
+++ _CMP_NEQ_UQ);
+++ // Need this condition only for cos
+++ // condition3 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q,
+++ // twos), fours)), fzeroes);
+++
+++ sine =
+++ _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(cosine, sine), condition1));
+++ sine = _mm256_sub_ps(
+++ sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
+++ _mm256_store_ps(bPtr, sine);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = sin(*aPtr++);
++ }
++- s = _mm256_div_ps(s, ftwos);
++-
++- sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
++- cosine = _mm256_sub_ps(fones, s);
++-
++- condition1 = _mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)), fzeroes, _CMP_NEQ_UQ);
++- condition2 = _mm256_cmp_ps(_mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS), _CMP_NEQ_UQ);
++- // Need this condition only for cos
++- //condition3 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, twos), fours)), fzeroes);
++-
++- sine = _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(cosine, sine), condition1));
++- sine = _mm256_sub_ps(sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
++- _mm256_store_ps(bPtr, sine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++) {
++- *bPtr++ = sin(*aPtr++);
++- }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for aligned */
++@@ -159,72 +180,100 @@ volk_32f_sin_32f_a_avx2_fma(float* bVector, const float* aVector, unsigned int n
++ static inline void
++ volk_32f_sin_32f_a_avx2(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- unsigned int i = 0;
++-
++- __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m256 sine, cosine, condition1, condition2;
++- __m256i q, r, ones, twos, fours;
++-
++- m4pi = _mm256_set1_ps(1.273239545);
++- pio4A = _mm256_set1_ps(0.78515625);
++- pio4B = _mm256_set1_ps(0.241876e-3);
++- ffours = _mm256_set1_ps(4.0);
++- ftwos = _mm256_set1_ps(2.0);
++- fones = _mm256_set1_ps(1.0);
++- fzeroes = _mm256_setzero_ps();
++- ones = _mm256_set1_epi32(1);
++- twos = _mm256_set1_epi32(2);
++- fours = _mm256_set1_epi32(4);
++-
++- cp1 = _mm256_set1_ps(1.0);
++- cp2 = _mm256_set1_ps(0.83333333e-1);
++- cp3 = _mm256_set1_ps(0.2777778e-2);
++- cp4 = _mm256_set1_ps(0.49603e-4);
++- cp5 = _mm256_set1_ps(0.551e-6);
++-
++- for(;number < eighthPoints; number++) {
++- aVal = _mm256_load_ps(aPtr);
++- s = _mm256_sub_ps(aVal, _mm256_and_ps(_mm256_mul_ps(aVal, ftwos), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
++- q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
++- r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
++-
++- s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4A));
++- s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4B));
++-
++- s = _mm256_div_ps(s, _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm256_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm256_mul_ps(_mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(_mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
++-
++- for(i = 0; i < 3; i++) {
++- s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ unsigned int i = 0;
+++
+++ __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones,
+++ fzeroes;
+++ __m256 sine, cosine, condition1, condition2;
+++ __m256i q, r, ones, twos, fours;
+++
+++ m4pi = _mm256_set1_ps(1.273239545);
+++ pio4A = _mm256_set1_ps(0.78515625);
+++ pio4B = _mm256_set1_ps(0.241876e-3);
+++ ffours = _mm256_set1_ps(4.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ fones = _mm256_set1_ps(1.0);
+++ fzeroes = _mm256_setzero_ps();
+++ ones = _mm256_set1_epi32(1);
+++ twos = _mm256_set1_epi32(2);
+++ fours = _mm256_set1_epi32(4);
+++
+++ cp1 = _mm256_set1_ps(1.0);
+++ cp2 = _mm256_set1_ps(0.83333333e-1);
+++ cp3 = _mm256_set1_ps(0.2777778e-2);
+++ cp4 = _mm256_set1_ps(0.49603e-4);
+++ cp5 = _mm256_set1_ps(0.551e-6);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ s = _mm256_sub_ps(aVal,
+++ _mm256_and_ps(_mm256_mul_ps(aVal, ftwos),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
+++ q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
+++ r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
+++
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4A));
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4B));
+++
+++ s = _mm256_div_ps(
+++ s,
+++ _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm256_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm256_mul_ps(
+++ _mm256_add_ps(
+++ _mm256_mul_ps(
+++ _mm256_sub_ps(
+++ _mm256_mul_ps(
+++ _mm256_add_ps(
+++ _mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(s, cp5), cp4),
+++ s),
+++ cp3),
+++ s),
+++ cp2),
+++ s),
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++) {
+++ s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ }
+++ s = _mm256_div_ps(s, ftwos);
+++
+++ sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
+++ cosine = _mm256_sub_ps(fones, s);
+++
+++ condition1 = _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)),
+++ fzeroes,
+++ _CMP_NEQ_UQ);
+++ condition2 = _mm256_cmp_ps(
+++ _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS),
+++ _CMP_NEQ_UQ);
+++ // Need this condition only for cos
+++ // condition3 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q,
+++ // twos), fours)), fzeroes);
+++
+++ sine =
+++ _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(cosine, sine), condition1));
+++ sine = _mm256_sub_ps(
+++ sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
+++ _mm256_store_ps(bPtr, sine);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = sin(*aPtr++);
++ }
++- s = _mm256_div_ps(s, ftwos);
++-
++- sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
++- cosine = _mm256_sub_ps(fones, s);
++-
++- condition1 = _mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)), fzeroes, _CMP_NEQ_UQ);
++- condition2 = _mm256_cmp_ps(_mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS), _CMP_NEQ_UQ);
++- // Need this condition only for cos
++- //condition3 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, twos), fours)), fzeroes);
++-
++- sine = _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(cosine, sine), condition1));
++- sine = _mm256_sub_ps(sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
++- _mm256_store_ps(bPtr, sine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++) {
++- *bPtr++ = sin(*aPtr++);
++- }
++ }
++
++ #endif /* LV_HAVE_AVX2 for aligned */
++@@ -235,72 +284,91 @@ volk_32f_sin_32f_a_avx2(float* bVector, const float* aVector, unsigned int num_p
++ static inline void
++ volk_32f_sin_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int quarterPoints = num_points / 4;
++- unsigned int i = 0;
++-
++- __m128 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m128 sine, cosine, condition1, condition2;
++- __m128i q, r, ones, twos, fours;
++-
++- m4pi = _mm_set1_ps(1.273239545);
++- pio4A = _mm_set1_ps(0.78515625);
++- pio4B = _mm_set1_ps(0.241876e-3);
++- ffours = _mm_set1_ps(4.0);
++- ftwos = _mm_set1_ps(2.0);
++- fones = _mm_set1_ps(1.0);
++- fzeroes = _mm_setzero_ps();
++- ones = _mm_set1_epi32(1);
++- twos = _mm_set1_epi32(2);
++- fours = _mm_set1_epi32(4);
++-
++- cp1 = _mm_set1_ps(1.0);
++- cp2 = _mm_set1_ps(0.83333333e-1);
++- cp3 = _mm_set1_ps(0.2777778e-2);
++- cp4 = _mm_set1_ps(0.49603e-4);
++- cp5 = _mm_set1_ps(0.551e-6);
++-
++- for(;number < quarterPoints; number++) {
++- aVal = _mm_load_ps(aPtr);
++- s = _mm_sub_ps(aVal, _mm_and_ps(_mm_mul_ps(aVal, ftwos), _mm_cmplt_ps(aVal, fzeroes)));
++- q = _mm_cvtps_epi32(_mm_floor_ps(_mm_mul_ps(s, m4pi)));
++- r = _mm_add_epi32(q, _mm_and_si128(q, ones));
++-
++- s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4A));
++- s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4B));
++-
++- s = _mm_div_ps(s, _mm_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
++-
++- for(i = 0; i < 3; i++) {
++- s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int quarterPoints = num_points / 4;
+++ unsigned int i = 0;
+++
+++ __m128 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones,
+++ fzeroes;
+++ __m128 sine, cosine, condition1, condition2;
+++ __m128i q, r, ones, twos, fours;
+++
+++ m4pi = _mm_set1_ps(1.273239545);
+++ pio4A = _mm_set1_ps(0.78515625);
+++ pio4B = _mm_set1_ps(0.241876e-3);
+++ ffours = _mm_set1_ps(4.0);
+++ ftwos = _mm_set1_ps(2.0);
+++ fones = _mm_set1_ps(1.0);
+++ fzeroes = _mm_setzero_ps();
+++ ones = _mm_set1_epi32(1);
+++ twos = _mm_set1_epi32(2);
+++ fours = _mm_set1_epi32(4);
+++
+++ cp1 = _mm_set1_ps(1.0);
+++ cp2 = _mm_set1_ps(0.83333333e-1);
+++ cp3 = _mm_set1_ps(0.2777778e-2);
+++ cp4 = _mm_set1_ps(0.49603e-4);
+++ cp5 = _mm_set1_ps(0.551e-6);
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
+++ s = _mm_sub_ps(aVal,
+++ _mm_and_ps(_mm_mul_ps(aVal, ftwos), _mm_cmplt_ps(aVal, fzeroes)));
+++ q = _mm_cvtps_epi32(_mm_floor_ps(_mm_mul_ps(s, m4pi)));
+++ r = _mm_add_epi32(q, _mm_and_si128(q, ones));
+++
+++ s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4A));
+++ s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4B));
+++
+++ s = _mm_div_ps(
+++ s, _mm_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm_mul_ps(
+++ _mm_add_ps(
+++ _mm_mul_ps(
+++ _mm_sub_ps(
+++ _mm_mul_ps(
+++ _mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s),
+++ cp3),
+++ s),
+++ cp2),
+++ s),
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++) {
+++ s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
+++ }
+++ s = _mm_div_ps(s, ftwos);
+++
+++ sine = _mm_sqrt_ps(_mm_mul_ps(_mm_sub_ps(ftwos, s), s));
+++ cosine = _mm_sub_ps(fones, s);
+++
+++ condition1 = _mm_cmpneq_ps(
+++ _mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, ones), twos)), fzeroes);
+++ condition2 = _mm_cmpneq_ps(
+++ _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(q, fours)), fzeroes),
+++ _mm_cmplt_ps(aVal, fzeroes));
+++ // Need this condition only for cos
+++ // condition3 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q,
+++ // twos), fours)), fzeroes);
+++
+++ sine = _mm_add_ps(sine, _mm_and_ps(_mm_sub_ps(cosine, sine), condition1));
+++ sine =
+++ _mm_sub_ps(sine, _mm_and_ps(_mm_mul_ps(sine, _mm_set1_ps(2.0f)), condition2));
+++ _mm_store_ps(bPtr, sine);
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = sinf(*aPtr++);
++ }
++- s = _mm_div_ps(s, ftwos);
++-
++- sine = _mm_sqrt_ps(_mm_mul_ps(_mm_sub_ps(ftwos, s), s));
++- cosine = _mm_sub_ps(fones, s);
++-
++- condition1 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, ones), twos)), fzeroes);
++- condition2 = _mm_cmpneq_ps(_mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(q, fours)), fzeroes), _mm_cmplt_ps(aVal, fzeroes));
++- // Need this condition only for cos
++- //condition3 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, twos), fours)), fzeroes);
++-
++- sine = _mm_add_ps(sine, _mm_and_ps(_mm_sub_ps(cosine, sine), condition1));
++- sine = _mm_sub_ps(sine, _mm_and_ps(_mm_mul_ps(sine, _mm_set1_ps(2.0f)), condition2));
++- _mm_store_ps(bPtr, sine);
++- aPtr += 4;
++- bPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++) {
++- *bPtr++ = sinf(*aPtr++);
++- }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for aligned */
++@@ -317,72 +385,93 @@ volk_32f_sin_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int num
++ static inline void
++ volk_32f_sin_32f_u_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- unsigned int i = 0;
++-
++- __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m256 sine, cosine, condition1, condition2;
++- __m256i q, r, ones, twos, fours;
++-
++- m4pi = _mm256_set1_ps(1.273239545);
++- pio4A = _mm256_set1_ps(0.78515625);
++- pio4B = _mm256_set1_ps(0.241876e-3);
++- ffours = _mm256_set1_ps(4.0);
++- ftwos = _mm256_set1_ps(2.0);
++- fones = _mm256_set1_ps(1.0);
++- fzeroes = _mm256_setzero_ps();
++- ones = _mm256_set1_epi32(1);
++- twos = _mm256_set1_epi32(2);
++- fours = _mm256_set1_epi32(4);
++-
++- cp1 = _mm256_set1_ps(1.0);
++- cp2 = _mm256_set1_ps(0.83333333e-1);
++- cp3 = _mm256_set1_ps(0.2777778e-2);
++- cp4 = _mm256_set1_ps(0.49603e-4);
++- cp5 = _mm256_set1_ps(0.551e-6);
++-
++- for(;number < eighthPoints; number++) {
++- aVal = _mm256_loadu_ps(aPtr);
++- s = _mm256_sub_ps(aVal, _mm256_and_ps(_mm256_mul_ps(aVal, ftwos), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
++- q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
++- r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
++-
++- s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4A, s);
++- s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4B, s);
++-
++- s = _mm256_div_ps(s, _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm256_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm256_mul_ps(_mm256_fmadd_ps(_mm256_fmsub_ps(_mm256_fmadd_ps(_mm256_fmsub_ps(s, cp5, cp4), s, cp3), s, cp2), s, cp1), s);
++-
++- for(i = 0; i < 3; i++) {
++- s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ unsigned int i = 0;
+++
+++ __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones,
+++ fzeroes;
+++ __m256 sine, cosine, condition1, condition2;
+++ __m256i q, r, ones, twos, fours;
+++
+++ m4pi = _mm256_set1_ps(1.273239545);
+++ pio4A = _mm256_set1_ps(0.78515625);
+++ pio4B = _mm256_set1_ps(0.241876e-3);
+++ ffours = _mm256_set1_ps(4.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ fones = _mm256_set1_ps(1.0);
+++ fzeroes = _mm256_setzero_ps();
+++ ones = _mm256_set1_epi32(1);
+++ twos = _mm256_set1_epi32(2);
+++ fours = _mm256_set1_epi32(4);
+++
+++ cp1 = _mm256_set1_ps(1.0);
+++ cp2 = _mm256_set1_ps(0.83333333e-1);
+++ cp3 = _mm256_set1_ps(0.2777778e-2);
+++ cp4 = _mm256_set1_ps(0.49603e-4);
+++ cp5 = _mm256_set1_ps(0.551e-6);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ s = _mm256_sub_ps(aVal,
+++ _mm256_and_ps(_mm256_mul_ps(aVal, ftwos),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
+++ q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
+++ r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
+++
+++ s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4A, s);
+++ s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4B, s);
+++
+++ s = _mm256_div_ps(
+++ s,
+++ _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm256_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm256_mul_ps(
+++ _mm256_fmadd_ps(
+++ _mm256_fmsub_ps(
+++ _mm256_fmadd_ps(_mm256_fmsub_ps(s, cp5, cp4), s, cp3), s, cp2),
+++ s,
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++) {
+++ s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ }
+++ s = _mm256_div_ps(s, ftwos);
+++
+++ sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
+++ cosine = _mm256_sub_ps(fones, s);
+++
+++ condition1 = _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)),
+++ fzeroes,
+++ _CMP_NEQ_UQ);
+++ condition2 = _mm256_cmp_ps(
+++ _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS),
+++ _CMP_NEQ_UQ);
+++ // Need this condition only for cos
+++ // condition3 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q,
+++ // twos), fours)), fzeroes);
+++
+++ sine =
+++ _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(cosine, sine), condition1));
+++ sine = _mm256_sub_ps(
+++ sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
+++ _mm256_storeu_ps(bPtr, sine);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = sin(*aPtr++);
++ }
++- s = _mm256_div_ps(s, ftwos);
++-
++- sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
++- cosine = _mm256_sub_ps(fones, s);
++-
++- condition1 = _mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)), fzeroes, _CMP_NEQ_UQ);
++- condition2 = _mm256_cmp_ps(_mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS), _CMP_NEQ_UQ);
++- // Need this condition only for cos
++- //condition3 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, twos), fours)), fzeroes);
++-
++- sine = _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(cosine, sine), condition1));
++- sine = _mm256_sub_ps(sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
++- _mm256_storeu_ps(bPtr, sine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++) {
++- *bPtr++ = sin(*aPtr++);
++- }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for unaligned */
++@@ -393,72 +482,100 @@ volk_32f_sin_32f_u_avx2_fma(float* bVector, const float* aVector, unsigned int n
++ static inline void
++ volk_32f_sin_32f_u_avx2(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- unsigned int i = 0;
++-
++- __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m256 sine, cosine, condition1, condition2;
++- __m256i q, r, ones, twos, fours;
++-
++- m4pi = _mm256_set1_ps(1.273239545);
++- pio4A = _mm256_set1_ps(0.78515625);
++- pio4B = _mm256_set1_ps(0.241876e-3);
++- ffours = _mm256_set1_ps(4.0);
++- ftwos = _mm256_set1_ps(2.0);
++- fones = _mm256_set1_ps(1.0);
++- fzeroes = _mm256_setzero_ps();
++- ones = _mm256_set1_epi32(1);
++- twos = _mm256_set1_epi32(2);
++- fours = _mm256_set1_epi32(4);
++-
++- cp1 = _mm256_set1_ps(1.0);
++- cp2 = _mm256_set1_ps(0.83333333e-1);
++- cp3 = _mm256_set1_ps(0.2777778e-2);
++- cp4 = _mm256_set1_ps(0.49603e-4);
++- cp5 = _mm256_set1_ps(0.551e-6);
++-
++- for(;number < eighthPoints; number++) {
++- aVal = _mm256_loadu_ps(aPtr);
++- s = _mm256_sub_ps(aVal, _mm256_and_ps(_mm256_mul_ps(aVal, ftwos), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
++- q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
++- r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
++-
++- s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4A));
++- s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4B));
++-
++- s = _mm256_div_ps(s, _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm256_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm256_mul_ps(_mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(_mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
++-
++- for(i = 0; i < 3; i++) {
++- s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ unsigned int i = 0;
+++
+++ __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones,
+++ fzeroes;
+++ __m256 sine, cosine, condition1, condition2;
+++ __m256i q, r, ones, twos, fours;
+++
+++ m4pi = _mm256_set1_ps(1.273239545);
+++ pio4A = _mm256_set1_ps(0.78515625);
+++ pio4B = _mm256_set1_ps(0.241876e-3);
+++ ffours = _mm256_set1_ps(4.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ fones = _mm256_set1_ps(1.0);
+++ fzeroes = _mm256_setzero_ps();
+++ ones = _mm256_set1_epi32(1);
+++ twos = _mm256_set1_epi32(2);
+++ fours = _mm256_set1_epi32(4);
+++
+++ cp1 = _mm256_set1_ps(1.0);
+++ cp2 = _mm256_set1_ps(0.83333333e-1);
+++ cp3 = _mm256_set1_ps(0.2777778e-2);
+++ cp4 = _mm256_set1_ps(0.49603e-4);
+++ cp5 = _mm256_set1_ps(0.551e-6);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ s = _mm256_sub_ps(aVal,
+++ _mm256_and_ps(_mm256_mul_ps(aVal, ftwos),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
+++ q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
+++ r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
+++
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4A));
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4B));
+++
+++ s = _mm256_div_ps(
+++ s,
+++ _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm256_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm256_mul_ps(
+++ _mm256_add_ps(
+++ _mm256_mul_ps(
+++ _mm256_sub_ps(
+++ _mm256_mul_ps(
+++ _mm256_add_ps(
+++ _mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(s, cp5), cp4),
+++ s),
+++ cp3),
+++ s),
+++ cp2),
+++ s),
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++) {
+++ s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ }
+++ s = _mm256_div_ps(s, ftwos);
+++
+++ sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
+++ cosine = _mm256_sub_ps(fones, s);
+++
+++ condition1 = _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)),
+++ fzeroes,
+++ _CMP_NEQ_UQ);
+++ condition2 = _mm256_cmp_ps(
+++ _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS),
+++ _CMP_NEQ_UQ);
+++ // Need this condition only for cos
+++ // condition3 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q,
+++ // twos), fours)), fzeroes);
+++
+++ sine =
+++ _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(cosine, sine), condition1));
+++ sine = _mm256_sub_ps(
+++ sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
+++ _mm256_storeu_ps(bPtr, sine);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = sin(*aPtr++);
++ }
++- s = _mm256_div_ps(s, ftwos);
++-
++- sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
++- cosine = _mm256_sub_ps(fones, s);
++-
++- condition1 = _mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)), fzeroes, _CMP_NEQ_UQ);
++- condition2 = _mm256_cmp_ps(_mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS), _CMP_NEQ_UQ);
++- // Need this condition only for cos
++- //condition3 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, twos), fours)), fzeroes);
++-
++- sine = _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(cosine, sine), condition1));
++- sine = _mm256_sub_ps(sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
++- _mm256_storeu_ps(bPtr, sine);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++) {
++- *bPtr++ = sin(*aPtr++);
++- }
++ }
++
++ #endif /* LV_HAVE_AVX2 for unaligned */
++@@ -470,70 +587,88 @@ volk_32f_sin_32f_u_avx2(float* bVector, const float* aVector, unsigned int num_p
++ static inline void
++ volk_32f_sin_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int quarterPoints = num_points / 4;
++- unsigned int i = 0;
++-
++- __m128 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m128 sine, cosine, condition1, condition2;
++- __m128i q, r, ones, twos, fours;
++-
++- m4pi = _mm_set1_ps(1.273239545);
++- pio4A = _mm_set1_ps(0.78515625);
++- pio4B = _mm_set1_ps(0.241876e-3);
++- ffours = _mm_set1_ps(4.0);
++- ftwos = _mm_set1_ps(2.0);
++- fones = _mm_set1_ps(1.0);
++- fzeroes = _mm_setzero_ps();
++- ones = _mm_set1_epi32(1);
++- twos = _mm_set1_epi32(2);
++- fours = _mm_set1_epi32(4);
++-
++- cp1 = _mm_set1_ps(1.0);
++- cp2 = _mm_set1_ps(0.83333333e-1);
++- cp3 = _mm_set1_ps(0.2777778e-2);
++- cp4 = _mm_set1_ps(0.49603e-4);
++- cp5 = _mm_set1_ps(0.551e-6);
++-
++- for(;number < quarterPoints; number++) {
++- aVal = _mm_loadu_ps(aPtr);
++- s = _mm_sub_ps(aVal, _mm_and_ps(_mm_mul_ps(aVal, ftwos), _mm_cmplt_ps(aVal, fzeroes)));
++- q = _mm_cvtps_epi32(_mm_floor_ps(_mm_mul_ps(s, m4pi)));
++- r = _mm_add_epi32(q, _mm_and_si128(q, ones));
++-
++- s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4A));
++- s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4B));
++-
++- s = _mm_div_ps(s, _mm_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
++-
++- for(i = 0; i < 3; i++) {
++- s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
++- }
++- s = _mm_div_ps(s, ftwos);
++-
++- sine = _mm_sqrt_ps(_mm_mul_ps(_mm_sub_ps(ftwos, s), s));
++- cosine = _mm_sub_ps(fones, s);
++-
++- condition1 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, ones), twos)), fzeroes);
++- condition2 = _mm_cmpneq_ps(_mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(q, fours)), fzeroes), _mm_cmplt_ps(aVal, fzeroes));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
++
++- sine = _mm_add_ps(sine, _mm_and_ps(_mm_sub_ps(cosine, sine), condition1));
++- sine = _mm_sub_ps(sine, _mm_and_ps(_mm_mul_ps(sine, _mm_set1_ps(2.0f)), condition2));
++- _mm_storeu_ps(bPtr, sine);
++- aPtr += 4;
++- bPtr += 4;
++- }
+++ unsigned int number = 0;
+++ unsigned int quarterPoints = num_points / 4;
+++ unsigned int i = 0;
+++
+++ __m128 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones,
+++ fzeroes;
+++ __m128 sine, cosine, condition1, condition2;
+++ __m128i q, r, ones, twos, fours;
+++
+++ m4pi = _mm_set1_ps(1.273239545);
+++ pio4A = _mm_set1_ps(0.78515625);
+++ pio4B = _mm_set1_ps(0.241876e-3);
+++ ffours = _mm_set1_ps(4.0);
+++ ftwos = _mm_set1_ps(2.0);
+++ fones = _mm_set1_ps(1.0);
+++ fzeroes = _mm_setzero_ps();
+++ ones = _mm_set1_epi32(1);
+++ twos = _mm_set1_epi32(2);
+++ fours = _mm_set1_epi32(4);
+++
+++ cp1 = _mm_set1_ps(1.0);
+++ cp2 = _mm_set1_ps(0.83333333e-1);
+++ cp3 = _mm_set1_ps(0.2777778e-2);
+++ cp4 = _mm_set1_ps(0.49603e-4);
+++ cp5 = _mm_set1_ps(0.551e-6);
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_loadu_ps(aPtr);
+++ s = _mm_sub_ps(aVal,
+++ _mm_and_ps(_mm_mul_ps(aVal, ftwos), _mm_cmplt_ps(aVal, fzeroes)));
+++ q = _mm_cvtps_epi32(_mm_floor_ps(_mm_mul_ps(s, m4pi)));
+++ r = _mm_add_epi32(q, _mm_and_si128(q, ones));
+++
+++ s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4A));
+++ s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4B));
+++
+++ s = _mm_div_ps(
+++ s, _mm_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm_mul_ps(
+++ _mm_add_ps(
+++ _mm_mul_ps(
+++ _mm_sub_ps(
+++ _mm_mul_ps(
+++ _mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s),
+++ cp3),
+++ s),
+++ cp2),
+++ s),
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++) {
+++ s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
+++ }
+++ s = _mm_div_ps(s, ftwos);
+++
+++ sine = _mm_sqrt_ps(_mm_mul_ps(_mm_sub_ps(ftwos, s), s));
+++ cosine = _mm_sub_ps(fones, s);
+++
+++ condition1 = _mm_cmpneq_ps(
+++ _mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, ones), twos)), fzeroes);
+++ condition2 = _mm_cmpneq_ps(
+++ _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(q, fours)), fzeroes),
+++ _mm_cmplt_ps(aVal, fzeroes));
+++
+++ sine = _mm_add_ps(sine, _mm_and_ps(_mm_sub_ps(cosine, sine), condition1));
+++ sine =
+++ _mm_sub_ps(sine, _mm_and_ps(_mm_mul_ps(sine, _mm_set1_ps(2.0f)), condition2));
+++ _mm_storeu_ps(bPtr, sine);
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *bPtr++ = sinf(*aPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = sinf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for unaligned */
++@@ -544,14 +679,13 @@ volk_32f_sin_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int num
++ static inline void
++ volk_32f_sin_32f_generic(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++) {
++- *bPtr++ = sinf(*aPtr++);
++- }
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
+++ for (number = 0; number < num_points; number++) {
+++ *bPtr++ = sinf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -562,30 +696,29 @@ volk_32f_sin_32f_generic(float* bVector, const float* aVector, unsigned int num_
++ #include <volk/volk_neon_intrinsics.h>
++
++ static inline void
++-volk_32f_sin_32f_neon(float* bVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_sin_32f_neon(float* bVector, const float* aVector, unsigned int num_points)
++ {
++ unsigned int number = 0;
++ unsigned int quarter_points = num_points / 4;
++ float* bVectorPtr = bVector;
++ const float* aVectorPtr = aVector;
++-
+++
++ float32x4_t b_vec;
++ float32x4_t a_vec;
++-
++- for(number = 0; number < quarter_points; number++) {
+++
+++ for (number = 0; number < quarter_points; number++) {
++ a_vec = vld1q_f32(aVectorPtr);
++ // Prefetch next one, speeds things up
++- __VOLK_PREFETCH(aVectorPtr+4);
+++ __VOLK_PREFETCH(aVectorPtr + 4);
++ b_vec = _vsinq_f32(a_vec);
++ vst1q_f32(bVectorPtr, b_vec);
++ // move pointers ahead
++- bVectorPtr+=4;
++- aVectorPtr+=4;
+++ bVectorPtr += 4;
+++ aVectorPtr += 4;
++ }
++-
+++
++ // Deal with the rest
++- for(number = quarter_points * 4; number < num_points; number++) {
+++ for (number = quarter_points * 4; number < num_points; number++) {
++ *bVectorPtr++ = sinf(*aVectorPtr++);
++ }
++ }
++diff --git a/kernels/volk/volk_32f_sqrt_32f.h b/kernels/volk/volk_32f_sqrt_32f.h
++index 84160af..667d356 100644
++--- a/kernels/volk/volk_32f_sqrt_32f.h
+++++ b/kernels/volk/volk_32f_sqrt_32f.h
++@@ -66,8 +66,8 @@
++ #define INCLUDED_volk_32f_sqrt_32f_a_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++@@ -75,28 +75,28 @@
++ static inline void
++ volk_32f_sqrt_32f_a_sse(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
++
++- __m128 aVal, cVal;
++- for(;number < quarterPoints; number++) {
++- aVal = _mm_load_ps(aPtr);
+++ __m128 aVal, cVal;
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
++
++- cVal = _mm_sqrt_ps(aVal);
+++ cVal = _mm_sqrt_ps(aVal);
++
++- _mm_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++) {
++- *cPtr++ = sqrtf(*aPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = sqrtf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE */
++@@ -107,28 +107,28 @@ volk_32f_sqrt_32f_a_sse(float* cVector, const float* aVector, unsigned int num_p
++ static inline void
++ volk_32f_sqrt_32f_a_avx(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
++
++- __m256 aVal, cVal;
++- for(;number < eighthPoints; number++) {
++- aVal = _mm256_load_ps(aPtr);
+++ __m256 aVal, cVal;
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
++
++- cVal = _mm256_sqrt_ps(aVal);
+++ cVal = _mm256_sqrt_ps(aVal);
++
++- _mm256_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++) {
++- *cPtr++ = sqrtf(*aPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = sqrtf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++@@ -140,24 +140,24 @@ volk_32f_sqrt_32f_a_avx(float* cVector, const float* aVector, unsigned int num_p
++ static inline void
++ volk_32f_sqrt_32f_neon(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++- unsigned int quarter_points = num_points / 4;
++- float32x4_t in_vec, out_vec;
++-
++- for(number = 0; number < quarter_points; number++) {
++- in_vec = vld1q_f32(aPtr);
++- // note that armv8 has vsqrt_f32 which will be much better
++- out_vec = vrecpeq_f32(vrsqrteq_f32(in_vec) );
++- vst1q_f32(cPtr, out_vec);
++- aPtr += 4;
++- cPtr += 4;
++- }
++-
++- for(number = quarter_points * 4; number < num_points; number++) {
++- *cPtr++ = sqrtf(*aPtr++);
++- }
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
+++ unsigned int quarter_points = num_points / 4;
+++ float32x4_t in_vec, out_vec;
+++
+++ for (number = 0; number < quarter_points; number++) {
+++ in_vec = vld1q_f32(aPtr);
+++ // note that armv8 has vsqrt_f32 which will be much better
+++ out_vec = vrecpeq_f32(vrsqrteq_f32(in_vec));
+++ vst1q_f32(cPtr, out_vec);
+++ aPtr += 4;
+++ cPtr += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ *cPtr++ = sqrtf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_NEON */
++@@ -168,13 +168,13 @@ volk_32f_sqrt_32f_neon(float* cVector, const float* aVector, unsigned int num_po
++ static inline void
++ volk_32f_sqrt_32f_generic(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++) {
++- *cPtr++ = sqrtf(*aPtr++);
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = sqrtf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -182,13 +182,12 @@ volk_32f_sqrt_32f_generic(float* cVector, const float* aVector, unsigned int num
++
++ #ifdef LV_HAVE_ORC
++
++-extern void
++-volk_32f_sqrt_32f_a_orc_impl(float *, const float*, unsigned int);
+++extern void volk_32f_sqrt_32f_a_orc_impl(float*, const float*, unsigned int);
++
++ static inline void
++ volk_32f_sqrt_32f_u_orc(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- volk_32f_sqrt_32f_a_orc_impl(cVector, aVector, num_points);
+++ volk_32f_sqrt_32f_a_orc_impl(cVector, aVector, num_points);
++ }
++
++ #endif /* LV_HAVE_ORC */
++@@ -199,36 +198,36 @@ volk_32f_sqrt_32f_u_orc(float* cVector, const float* aVector, unsigned int num_p
++ #define INCLUDED_volk_32f_sqrt_32f_u_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++ static inline void
++ volk_32f_sqrt_32f_u_avx(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
++
++- __m256 aVal, cVal;
++- for(;number < eighthPoints; number++) {
++- aVal = _mm256_loadu_ps(aPtr);
+++ __m256 aVal, cVal;
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
++
++- cVal = _mm256_sqrt_ps(aVal);
+++ cVal = _mm256_sqrt_ps(aVal);
++
++- _mm256_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++) {
++- *cPtr++ = sqrtf(*aPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = sqrtf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++diff --git a/kernels/volk/volk_32f_stddev_and_mean_32f_x2.h b/kernels/volk/volk_32f_stddev_and_mean_32f_x2.h
++index 8e996e2..6ad0f17 100644
++--- a/kernels/volk/volk_32f_stddev_and_mean_32f_x2.h
+++++ b/kernels/volk/volk_32f_stddev_and_mean_32f_x2.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_stddev_and_mean_32f_x2(float* stddev, float* mean, const float* inputBuffer, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_stddev_and_mean_32f_x2(float* stddev, float* mean, const float*
+++ * inputBuffer, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li inputBuffer: The buffer of points.
++@@ -41,10 +41,8 @@
++ * \li mean: The mean of the input buffer.
++ *
++ * \b Example
++- * Generate random numbers with c++11's normal distribution and estimate the mean and standard deviation
++- * \code
++- * int N = 1000;
++- * unsigned int alignment = volk_get_alignment();
+++ * Generate random numbers with c++11's normal distribution and estimate the mean and
+++ * standard deviation \code int N = 1000; unsigned int alignment = volk_get_alignment();
++ * float* rand_numbers = (float*)volk_malloc(sizeof(float)*N, alignment);
++ * float* mean = (float*)volk_malloc(sizeof(float), alignment);
++ * float* stddev = (float*)volk_malloc(sizeof(float), alignment);
++@@ -71,88 +69,94 @@
++ #ifndef INCLUDED_volk_32f_stddev_and_mean_32f_x2_a_H
++ #define INCLUDED_volk_32f_stddev_and_mean_32f_x2_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_stddev_and_mean_32f_x2_a_avx(float* stddev, float* mean,
++- const float* inputBuffer,
++- unsigned int num_points)
+++static inline void volk_32f_stddev_and_mean_32f_x2_a_avx(float* stddev,
+++ float* mean,
+++ const float* inputBuffer,
+++ unsigned int num_points)
++ {
++- float stdDev = 0;
++- float newMean = 0;
++- if(num_points > 0){
++- unsigned int number = 0;
++- const unsigned int thirtySecondthPoints = num_points / 32;
++-
++- const float* aPtr = inputBuffer;
++- __VOLK_ATTR_ALIGNED(32) float meanBuffer[8];
++- __VOLK_ATTR_ALIGNED(32) float squareBuffer[8];
++-
++- __m256 accumulator = _mm256_setzero_ps();
++- __m256 squareAccumulator = _mm256_setzero_ps();
++- __m256 aVal1, aVal2, aVal3, aVal4;
++- __m256 cVal1, cVal2, cVal3, cVal4;
++- for(;number < thirtySecondthPoints; number++) {
++- aVal1 = _mm256_load_ps(aPtr); aPtr += 8;
++- cVal1 = _mm256_dp_ps(aVal1, aVal1, 0xF1);
++- accumulator = _mm256_add_ps(accumulator, aVal1); // accumulator += x
++-
++- aVal2 = _mm256_load_ps(aPtr); aPtr += 8;
++- cVal2 = _mm256_dp_ps(aVal2, aVal2, 0xF2);
++- accumulator = _mm256_add_ps(accumulator, aVal2); // accumulator += x
++-
++- aVal3 = _mm256_load_ps(aPtr); aPtr += 8;
++- cVal3 = _mm256_dp_ps(aVal3, aVal3, 0xF4);
++- accumulator = _mm256_add_ps(accumulator, aVal3); // accumulator += x
++-
++- aVal4 = _mm256_load_ps(aPtr); aPtr += 8;
++- cVal4 = _mm256_dp_ps(aVal4, aVal4, 0xF8);
++- accumulator = _mm256_add_ps(accumulator, aVal4); // accumulator += x
++-
++- cVal1 = _mm256_or_ps(cVal1, cVal2);
++- cVal3 = _mm256_or_ps(cVal3, cVal4);
++- cVal1 = _mm256_or_ps(cVal1, cVal3);
++-
++- squareAccumulator = _mm256_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2
++- }
++- _mm256_store_ps(meanBuffer,accumulator); // Store the results back into the C container
++- _mm256_store_ps(squareBuffer,squareAccumulator); // Store the results back into the C container
++- newMean = meanBuffer[0];
++- newMean += meanBuffer[1];
++- newMean += meanBuffer[2];
++- newMean += meanBuffer[3];
++- newMean += meanBuffer[4];
++- newMean += meanBuffer[5];
++- newMean += meanBuffer[6];
++- newMean += meanBuffer[7];
++- stdDev = squareBuffer[0];
++- stdDev += squareBuffer[1];
++- stdDev += squareBuffer[2];
++- stdDev += squareBuffer[3];
++- stdDev += squareBuffer[4];
++- stdDev += squareBuffer[5];
++- stdDev += squareBuffer[6];
++- stdDev += squareBuffer[7];
++-
++- number = thirtySecondthPoints * 32;
++- for(;number < num_points; number++){
++- stdDev += (*aPtr) * (*aPtr);
++- newMean += *aPtr++;
+++ float stdDev = 0;
+++ float newMean = 0;
+++ if (num_points > 0) {
+++ unsigned int number = 0;
+++ const unsigned int thirtySecondthPoints = num_points / 32;
+++
+++ const float* aPtr = inputBuffer;
+++ __VOLK_ATTR_ALIGNED(32) float meanBuffer[8];
+++ __VOLK_ATTR_ALIGNED(32) float squareBuffer[8];
+++
+++ __m256 accumulator = _mm256_setzero_ps();
+++ __m256 squareAccumulator = _mm256_setzero_ps();
+++ __m256 aVal1, aVal2, aVal3, aVal4;
+++ __m256 cVal1, cVal2, cVal3, cVal4;
+++ for (; number < thirtySecondthPoints; number++) {
+++ aVal1 = _mm256_load_ps(aPtr);
+++ aPtr += 8;
+++ cVal1 = _mm256_dp_ps(aVal1, aVal1, 0xF1);
+++ accumulator = _mm256_add_ps(accumulator, aVal1); // accumulator += x
+++
+++ aVal2 = _mm256_load_ps(aPtr);
+++ aPtr += 8;
+++ cVal2 = _mm256_dp_ps(aVal2, aVal2, 0xF2);
+++ accumulator = _mm256_add_ps(accumulator, aVal2); // accumulator += x
+++
+++ aVal3 = _mm256_load_ps(aPtr);
+++ aPtr += 8;
+++ cVal3 = _mm256_dp_ps(aVal3, aVal3, 0xF4);
+++ accumulator = _mm256_add_ps(accumulator, aVal3); // accumulator += x
+++
+++ aVal4 = _mm256_load_ps(aPtr);
+++ aPtr += 8;
+++ cVal4 = _mm256_dp_ps(aVal4, aVal4, 0xF8);
+++ accumulator = _mm256_add_ps(accumulator, aVal4); // accumulator += x
+++
+++ cVal1 = _mm256_or_ps(cVal1, cVal2);
+++ cVal3 = _mm256_or_ps(cVal3, cVal4);
+++ cVal1 = _mm256_or_ps(cVal1, cVal3);
+++
+++ squareAccumulator =
+++ _mm256_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2
+++ }
+++ _mm256_store_ps(meanBuffer,
+++ accumulator); // Store the results back into the C container
+++ _mm256_store_ps(squareBuffer,
+++ squareAccumulator); // Store the results back into the C container
+++ newMean = meanBuffer[0];
+++ newMean += meanBuffer[1];
+++ newMean += meanBuffer[2];
+++ newMean += meanBuffer[3];
+++ newMean += meanBuffer[4];
+++ newMean += meanBuffer[5];
+++ newMean += meanBuffer[6];
+++ newMean += meanBuffer[7];
+++ stdDev = squareBuffer[0];
+++ stdDev += squareBuffer[1];
+++ stdDev += squareBuffer[2];
+++ stdDev += squareBuffer[3];
+++ stdDev += squareBuffer[4];
+++ stdDev += squareBuffer[5];
+++ stdDev += squareBuffer[6];
+++ stdDev += squareBuffer[7];
+++
+++ number = thirtySecondthPoints * 32;
+++ for (; number < num_points; number++) {
+++ stdDev += (*aPtr) * (*aPtr);
+++ newMean += *aPtr++;
+++ }
+++ newMean /= num_points;
+++ stdDev /= num_points;
+++ stdDev -= (newMean * newMean);
+++ stdDev = sqrtf(stdDev);
++ }
++- newMean /= num_points;
++- stdDev /= num_points;
++- stdDev -= (newMean * newMean);
++- stdDev = sqrtf(stdDev);
++- }
++- *stddev = stdDev;
++- *mean = newMean;
++-
+++ *stddev = stdDev;
+++ *mean = newMean;
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -160,151 +164,164 @@ volk_32f_stddev_and_mean_32f_x2_a_avx(float* stddev, float* mean,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_stddev_and_mean_32f_x2_u_avx(float* stddev, float* mean,
++- const float* inputBuffer,
++- unsigned int num_points)
+++static inline void volk_32f_stddev_and_mean_32f_x2_u_avx(float* stddev,
+++ float* mean,
+++ const float* inputBuffer,
+++ unsigned int num_points)
++ {
++- float stdDev = 0;
++- float newMean = 0;
++- if(num_points > 0){
++- unsigned int number = 0;
++- const unsigned int thirtySecondthPoints = num_points / 32;
++-
++- const float* aPtr = inputBuffer;
++- __VOLK_ATTR_ALIGNED(32) float meanBuffer[8];
++- __VOLK_ATTR_ALIGNED(32) float squareBuffer[8];
++-
++- __m256 accumulator = _mm256_setzero_ps();
++- __m256 squareAccumulator = _mm256_setzero_ps();
++- __m256 aVal1, aVal2, aVal3, aVal4;
++- __m256 cVal1, cVal2, cVal3, cVal4;
++- for(;number < thirtySecondthPoints; number++) {
++- aVal1 = _mm256_loadu_ps(aPtr); aPtr += 8;
++- cVal1 = _mm256_dp_ps(aVal1, aVal1, 0xF1);
++- accumulator = _mm256_add_ps(accumulator, aVal1); // accumulator += x
++-
++- aVal2 = _mm256_loadu_ps(aPtr); aPtr += 8;
++- cVal2 = _mm256_dp_ps(aVal2, aVal2, 0xF2);
++- accumulator = _mm256_add_ps(accumulator, aVal2); // accumulator += x
++-
++- aVal3 = _mm256_loadu_ps(aPtr); aPtr += 8;
++- cVal3 = _mm256_dp_ps(aVal3, aVal3, 0xF4);
++- accumulator = _mm256_add_ps(accumulator, aVal3); // accumulator += x
++-
++- aVal4 = _mm256_loadu_ps(aPtr); aPtr += 8;
++- cVal4 = _mm256_dp_ps(aVal4, aVal4, 0xF8);
++- accumulator = _mm256_add_ps(accumulator, aVal4); // accumulator += x
++-
++- cVal1 = _mm256_or_ps(cVal1, cVal2);
++- cVal3 = _mm256_or_ps(cVal3, cVal4);
++- cVal1 = _mm256_or_ps(cVal1, cVal3);
++-
++- squareAccumulator = _mm256_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2
++- }
++- _mm256_store_ps(meanBuffer,accumulator); // Store the results back into the C container
++- _mm256_store_ps(squareBuffer,squareAccumulator); // Store the results back into the C container
++- newMean = meanBuffer[0];
++- newMean += meanBuffer[1];
++- newMean += meanBuffer[2];
++- newMean += meanBuffer[3];
++- newMean += meanBuffer[4];
++- newMean += meanBuffer[5];
++- newMean += meanBuffer[6];
++- newMean += meanBuffer[7];
++- stdDev = squareBuffer[0];
++- stdDev += squareBuffer[1];
++- stdDev += squareBuffer[2];
++- stdDev += squareBuffer[3];
++- stdDev += squareBuffer[4];
++- stdDev += squareBuffer[5];
++- stdDev += squareBuffer[6];
++- stdDev += squareBuffer[7];
++-
++- number = thirtySecondthPoints * 32;
++- for(;number < num_points; number++){
++- stdDev += (*aPtr) * (*aPtr);
++- newMean += *aPtr++;
+++ float stdDev = 0;
+++ float newMean = 0;
+++ if (num_points > 0) {
+++ unsigned int number = 0;
+++ const unsigned int thirtySecondthPoints = num_points / 32;
+++
+++ const float* aPtr = inputBuffer;
+++ __VOLK_ATTR_ALIGNED(32) float meanBuffer[8];
+++ __VOLK_ATTR_ALIGNED(32) float squareBuffer[8];
+++
+++ __m256 accumulator = _mm256_setzero_ps();
+++ __m256 squareAccumulator = _mm256_setzero_ps();
+++ __m256 aVal1, aVal2, aVal3, aVal4;
+++ __m256 cVal1, cVal2, cVal3, cVal4;
+++ for (; number < thirtySecondthPoints; number++) {
+++ aVal1 = _mm256_loadu_ps(aPtr);
+++ aPtr += 8;
+++ cVal1 = _mm256_dp_ps(aVal1, aVal1, 0xF1);
+++ accumulator = _mm256_add_ps(accumulator, aVal1); // accumulator += x
+++
+++ aVal2 = _mm256_loadu_ps(aPtr);
+++ aPtr += 8;
+++ cVal2 = _mm256_dp_ps(aVal2, aVal2, 0xF2);
+++ accumulator = _mm256_add_ps(accumulator, aVal2); // accumulator += x
+++
+++ aVal3 = _mm256_loadu_ps(aPtr);
+++ aPtr += 8;
+++ cVal3 = _mm256_dp_ps(aVal3, aVal3, 0xF4);
+++ accumulator = _mm256_add_ps(accumulator, aVal3); // accumulator += x
+++
+++ aVal4 = _mm256_loadu_ps(aPtr);
+++ aPtr += 8;
+++ cVal4 = _mm256_dp_ps(aVal4, aVal4, 0xF8);
+++ accumulator = _mm256_add_ps(accumulator, aVal4); // accumulator += x
+++
+++ cVal1 = _mm256_or_ps(cVal1, cVal2);
+++ cVal3 = _mm256_or_ps(cVal3, cVal4);
+++ cVal1 = _mm256_or_ps(cVal1, cVal3);
+++
+++ squareAccumulator =
+++ _mm256_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2
+++ }
+++ _mm256_store_ps(meanBuffer,
+++ accumulator); // Store the results back into the C container
+++ _mm256_store_ps(squareBuffer,
+++ squareAccumulator); // Store the results back into the C container
+++ newMean = meanBuffer[0];
+++ newMean += meanBuffer[1];
+++ newMean += meanBuffer[2];
+++ newMean += meanBuffer[3];
+++ newMean += meanBuffer[4];
+++ newMean += meanBuffer[5];
+++ newMean += meanBuffer[6];
+++ newMean += meanBuffer[7];
+++ stdDev = squareBuffer[0];
+++ stdDev += squareBuffer[1];
+++ stdDev += squareBuffer[2];
+++ stdDev += squareBuffer[3];
+++ stdDev += squareBuffer[4];
+++ stdDev += squareBuffer[5];
+++ stdDev += squareBuffer[6];
+++ stdDev += squareBuffer[7];
+++
+++ number = thirtySecondthPoints * 32;
+++ for (; number < num_points; number++) {
+++ stdDev += (*aPtr) * (*aPtr);
+++ newMean += *aPtr++;
+++ }
+++ newMean /= num_points;
+++ stdDev /= num_points;
+++ stdDev -= (newMean * newMean);
+++ stdDev = sqrtf(stdDev);
++ }
++- newMean /= num_points;
++- stdDev /= num_points;
++- stdDev -= (newMean * newMean);
++- stdDev = sqrtf(stdDev);
++- }
++- *stddev = stdDev;
++- *mean = newMean;
++-
+++ *stddev = stdDev;
+++ *mean = newMean;
++ }
++ #endif /* LV_HAVE_AVX */
++
++
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++-static inline void
++-volk_32f_stddev_and_mean_32f_x2_a_sse4_1(float* stddev, float* mean,
++- const float* inputBuffer,
++- unsigned int num_points)
+++static inline void volk_32f_stddev_and_mean_32f_x2_a_sse4_1(float* stddev,
+++ float* mean,
+++ const float* inputBuffer,
+++ unsigned int num_points)
++ {
++- float returnValue = 0;
++- float newMean = 0;
++- if(num_points > 0){
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- const float* aPtr = inputBuffer;
++- __VOLK_ATTR_ALIGNED(16) float meanBuffer[4];
++- __VOLK_ATTR_ALIGNED(16) float squareBuffer[4];
++-
++- __m128 accumulator = _mm_setzero_ps();
++- __m128 squareAccumulator = _mm_setzero_ps();
++- __m128 aVal1, aVal2, aVal3, aVal4;
++- __m128 cVal1, cVal2, cVal3, cVal4;
++- for(;number < sixteenthPoints; number++) {
++- aVal1 = _mm_load_ps(aPtr); aPtr += 4;
++- cVal1 = _mm_dp_ps(aVal1, aVal1, 0xF1);
++- accumulator = _mm_add_ps(accumulator, aVal1); // accumulator += x
++-
++- aVal2 = _mm_load_ps(aPtr); aPtr += 4;
++- cVal2 = _mm_dp_ps(aVal2, aVal2, 0xF2);
++- accumulator = _mm_add_ps(accumulator, aVal2); // accumulator += x
++-
++- aVal3 = _mm_load_ps(aPtr); aPtr += 4;
++- cVal3 = _mm_dp_ps(aVal3, aVal3, 0xF4);
++- accumulator = _mm_add_ps(accumulator, aVal3); // accumulator += x
++-
++- aVal4 = _mm_load_ps(aPtr); aPtr += 4;
++- cVal4 = _mm_dp_ps(aVal4, aVal4, 0xF8);
++- accumulator = _mm_add_ps(accumulator, aVal4); // accumulator += x
++-
++- cVal1 = _mm_or_ps(cVal1, cVal2);
++- cVal3 = _mm_or_ps(cVal3, cVal4);
++- cVal1 = _mm_or_ps(cVal1, cVal3);
++-
++- squareAccumulator = _mm_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2
++- }
++- _mm_store_ps(meanBuffer,accumulator); // Store the results back into the C container
++- _mm_store_ps(squareBuffer,squareAccumulator); // Store the results back into the C container
++- newMean = meanBuffer[0];
++- newMean += meanBuffer[1];
++- newMean += meanBuffer[2];
++- newMean += meanBuffer[3];
++- returnValue = squareBuffer[0];
++- returnValue += squareBuffer[1];
++- returnValue += squareBuffer[2];
++- returnValue += squareBuffer[3];
++-
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- returnValue += (*aPtr) * (*aPtr);
++- newMean += *aPtr++;
+++ float returnValue = 0;
+++ float newMean = 0;
+++ if (num_points > 0) {
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ const float* aPtr = inputBuffer;
+++ __VOLK_ATTR_ALIGNED(16) float meanBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float squareBuffer[4];
+++
+++ __m128 accumulator = _mm_setzero_ps();
+++ __m128 squareAccumulator = _mm_setzero_ps();
+++ __m128 aVal1, aVal2, aVal3, aVal4;
+++ __m128 cVal1, cVal2, cVal3, cVal4;
+++ for (; number < sixteenthPoints; number++) {
+++ aVal1 = _mm_load_ps(aPtr);
+++ aPtr += 4;
+++ cVal1 = _mm_dp_ps(aVal1, aVal1, 0xF1);
+++ accumulator = _mm_add_ps(accumulator, aVal1); // accumulator += x
+++
+++ aVal2 = _mm_load_ps(aPtr);
+++ aPtr += 4;
+++ cVal2 = _mm_dp_ps(aVal2, aVal2, 0xF2);
+++ accumulator = _mm_add_ps(accumulator, aVal2); // accumulator += x
+++
+++ aVal3 = _mm_load_ps(aPtr);
+++ aPtr += 4;
+++ cVal3 = _mm_dp_ps(aVal3, aVal3, 0xF4);
+++ accumulator = _mm_add_ps(accumulator, aVal3); // accumulator += x
+++
+++ aVal4 = _mm_load_ps(aPtr);
+++ aPtr += 4;
+++ cVal4 = _mm_dp_ps(aVal4, aVal4, 0xF8);
+++ accumulator = _mm_add_ps(accumulator, aVal4); // accumulator += x
+++
+++ cVal1 = _mm_or_ps(cVal1, cVal2);
+++ cVal3 = _mm_or_ps(cVal3, cVal4);
+++ cVal1 = _mm_or_ps(cVal1, cVal3);
+++
+++ squareAccumulator =
+++ _mm_add_ps(squareAccumulator, cVal1); // squareAccumulator += x^2
+++ }
+++ _mm_store_ps(meanBuffer,
+++ accumulator); // Store the results back into the C container
+++ _mm_store_ps(squareBuffer,
+++ squareAccumulator); // Store the results back into the C container
+++ newMean = meanBuffer[0];
+++ newMean += meanBuffer[1];
+++ newMean += meanBuffer[2];
+++ newMean += meanBuffer[3];
+++ returnValue = squareBuffer[0];
+++ returnValue += squareBuffer[1];
+++ returnValue += squareBuffer[2];
+++ returnValue += squareBuffer[3];
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ returnValue += (*aPtr) * (*aPtr);
+++ newMean += *aPtr++;
+++ }
+++ newMean /= num_points;
+++ returnValue /= num_points;
+++ returnValue -= (newMean * newMean);
+++ returnValue = sqrtf(returnValue);
++ }
++- newMean /= num_points;
++- returnValue /= num_points;
++- returnValue -= (newMean * newMean);
++- returnValue = sqrtf(returnValue);
++- }
++- *stddev = returnValue;
++- *mean = newMean;
+++ *stddev = returnValue;
+++ *mean = newMean;
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++@@ -312,86 +329,86 @@ volk_32f_stddev_and_mean_32f_x2_a_sse4_1(float* stddev, float* mean,
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_stddev_and_mean_32f_x2_a_sse(float* stddev, float* mean,
++- const float* inputBuffer,
++- unsigned int num_points)
+++static inline void volk_32f_stddev_and_mean_32f_x2_a_sse(float* stddev,
+++ float* mean,
+++ const float* inputBuffer,
+++ unsigned int num_points)
++ {
++- float returnValue = 0;
++- float newMean = 0;
++- if(num_points > 0){
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* aPtr = inputBuffer;
++- __VOLK_ATTR_ALIGNED(16) float meanBuffer[4];
++- __VOLK_ATTR_ALIGNED(16) float squareBuffer[4];
++-
++- __m128 accumulator = _mm_setzero_ps();
++- __m128 squareAccumulator = _mm_setzero_ps();
++- __m128 aVal = _mm_setzero_ps();
++- for(;number < quarterPoints; number++) {
++- aVal = _mm_load_ps(aPtr); // aVal = x
++- accumulator = _mm_add_ps(accumulator, aVal); // accumulator += x
++- aVal = _mm_mul_ps(aVal, aVal); // squareAccumulator += x^2
++- squareAccumulator = _mm_add_ps(squareAccumulator, aVal);
++- aPtr += 4;
+++ float returnValue = 0;
+++ float newMean = 0;
+++ if (num_points > 0) {
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* aPtr = inputBuffer;
+++ __VOLK_ATTR_ALIGNED(16) float meanBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float squareBuffer[4];
+++
+++ __m128 accumulator = _mm_setzero_ps();
+++ __m128 squareAccumulator = _mm_setzero_ps();
+++ __m128 aVal = _mm_setzero_ps();
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr); // aVal = x
+++ accumulator = _mm_add_ps(accumulator, aVal); // accumulator += x
+++ aVal = _mm_mul_ps(aVal, aVal); // squareAccumulator += x^2
+++ squareAccumulator = _mm_add_ps(squareAccumulator, aVal);
+++ aPtr += 4;
+++ }
+++ _mm_store_ps(meanBuffer,
+++ accumulator); // Store the results back into the C container
+++ _mm_store_ps(squareBuffer,
+++ squareAccumulator); // Store the results back into the C container
+++ newMean = meanBuffer[0];
+++ newMean += meanBuffer[1];
+++ newMean += meanBuffer[2];
+++ newMean += meanBuffer[3];
+++ returnValue = squareBuffer[0];
+++ returnValue += squareBuffer[1];
+++ returnValue += squareBuffer[2];
+++ returnValue += squareBuffer[3];
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ returnValue += (*aPtr) * (*aPtr);
+++ newMean += *aPtr++;
+++ }
+++ newMean /= num_points;
+++ returnValue /= num_points;
+++ returnValue -= (newMean * newMean);
+++ returnValue = sqrtf(returnValue);
++ }
++- _mm_store_ps(meanBuffer,accumulator); // Store the results back into the C container
++- _mm_store_ps(squareBuffer,squareAccumulator); // Store the results back into the C container
++- newMean = meanBuffer[0];
++- newMean += meanBuffer[1];
++- newMean += meanBuffer[2];
++- newMean += meanBuffer[3];
++- returnValue = squareBuffer[0];
++- returnValue += squareBuffer[1];
++- returnValue += squareBuffer[2];
++- returnValue += squareBuffer[3];
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- returnValue += (*aPtr) * (*aPtr);
++- newMean += *aPtr++;
++- }
++- newMean /= num_points;
++- returnValue /= num_points;
++- returnValue -= (newMean * newMean);
++- returnValue = sqrtf(returnValue);
++- }
++- *stddev = returnValue;
++- *mean = newMean;
+++ *stddev = returnValue;
+++ *mean = newMean;
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_stddev_and_mean_32f_x2_generic(float* stddev, float* mean,
++- const float* inputBuffer,
++- unsigned int num_points)
+++static inline void volk_32f_stddev_and_mean_32f_x2_generic(float* stddev,
+++ float* mean,
+++ const float* inputBuffer,
+++ unsigned int num_points)
++ {
++- float returnValue = 0;
++- float newMean = 0;
++- if(num_points > 0){
++- const float* aPtr = inputBuffer;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- returnValue += (*aPtr) * (*aPtr);
++- newMean += *aPtr++;
+++ float returnValue = 0;
+++ float newMean = 0;
+++ if (num_points > 0) {
+++ const float* aPtr = inputBuffer;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ returnValue += (*aPtr) * (*aPtr);
+++ newMean += *aPtr++;
+++ }
+++ newMean /= num_points;
+++ returnValue /= num_points;
+++ returnValue -= (newMean * newMean);
+++ returnValue = sqrtf(returnValue);
++ }
++- newMean /= num_points;
++- returnValue /= num_points;
++- returnValue -= (newMean * newMean);
++- returnValue = sqrtf(returnValue);
++- }
++- *stddev = returnValue;
++- *mean = newMean;
+++ *stddev = returnValue;
+++ *mean = newMean;
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++-
++ #endif /* INCLUDED_volk_32f_stddev_and_mean_32f_x2_a_H */
++diff --git a/kernels/volk/volk_32f_tan_32f.h b/kernels/volk/volk_32f_tan_32f.h
++index 239b745..a623a66 100644
++--- a/kernels/volk/volk_32f_tan_32f.h
+++++ b/kernels/volk/volk_32f_tan_32f.h
++@@ -71,9 +71,9 @@
++ * \endcode
++ */
++
++-#include <stdio.h>
++-#include <math.h>
++ #include <inttypes.h>
+++#include <math.h>
+++#include <stdio.h>
++
++ #ifndef INCLUDED_volk_32f_tan_32f_a_H
++ #define INCLUDED_volk_32f_tan_32f_a_H
++@@ -82,78 +82,102 @@
++ #include <immintrin.h>
++
++ static inline void
++-volk_32f_tan_32f_a_avx2_fma(float* bVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tan_32f_a_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- unsigned int i = 0;
++-
++- __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m256 sine, cosine, tangent, condition1, condition2, condition3;
++- __m256i q, r, ones, twos, fours;
++-
++- m4pi = _mm256_set1_ps(1.273239545);
++- pio4A = _mm256_set1_ps(0.78515625);
++- pio4B = _mm256_set1_ps(0.241876e-3);
++- ffours = _mm256_set1_ps(4.0);
++- ftwos = _mm256_set1_ps(2.0);
++- fones = _mm256_set1_ps(1.0);
++- fzeroes = _mm256_setzero_ps();
++- ones = _mm256_set1_epi32(1);
++- twos = _mm256_set1_epi32(2);
++- fours = _mm256_set1_epi32(4);
++-
++- cp1 = _mm256_set1_ps(1.0);
++- cp2 = _mm256_set1_ps(0.83333333e-1);
++- cp3 = _mm256_set1_ps(0.2777778e-2);
++- cp4 = _mm256_set1_ps(0.49603e-4);
++- cp5 = _mm256_set1_ps(0.551e-6);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- s = _mm256_sub_ps(aVal, _mm256_and_ps(_mm256_mul_ps(aVal, ftwos), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
++- q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
++- r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
++-
++- s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4A, s);
++- s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4B, s);
++-
++- s = _mm256_div_ps(s, _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm256_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm256_mul_ps(_mm256_fmadd_ps(_mm256_fmsub_ps(_mm256_fmadd_ps(_mm256_fmsub_ps(s, cp5, cp4), s, cp3), s, cp2), s, cp1), s);
++-
++- for(i = 0; i < 3; i++){
++- s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ unsigned int i = 0;
+++
+++ __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones,
+++ fzeroes;
+++ __m256 sine, cosine, tangent, condition1, condition2, condition3;
+++ __m256i q, r, ones, twos, fours;
+++
+++ m4pi = _mm256_set1_ps(1.273239545);
+++ pio4A = _mm256_set1_ps(0.78515625);
+++ pio4B = _mm256_set1_ps(0.241876e-3);
+++ ffours = _mm256_set1_ps(4.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ fones = _mm256_set1_ps(1.0);
+++ fzeroes = _mm256_setzero_ps();
+++ ones = _mm256_set1_epi32(1);
+++ twos = _mm256_set1_epi32(2);
+++ fours = _mm256_set1_epi32(4);
+++
+++ cp1 = _mm256_set1_ps(1.0);
+++ cp2 = _mm256_set1_ps(0.83333333e-1);
+++ cp3 = _mm256_set1_ps(0.2777778e-2);
+++ cp4 = _mm256_set1_ps(0.49603e-4);
+++ cp5 = _mm256_set1_ps(0.551e-6);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ s = _mm256_sub_ps(aVal,
+++ _mm256_and_ps(_mm256_mul_ps(aVal, ftwos),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
+++ q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
+++ r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
+++
+++ s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4A, s);
+++ s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4B, s);
+++
+++ s = _mm256_div_ps(
+++ s,
+++ _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm256_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm256_mul_ps(
+++ _mm256_fmadd_ps(
+++ _mm256_fmsub_ps(
+++ _mm256_fmadd_ps(_mm256_fmsub_ps(s, cp5, cp4), s, cp3), s, cp2),
+++ s,
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++) {
+++ s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ }
+++ s = _mm256_div_ps(s, ftwos);
+++
+++ sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
+++ cosine = _mm256_sub_ps(fones, s);
+++
+++ condition1 = _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)),
+++ fzeroes,
+++ _CMP_NEQ_UQ);
+++ condition2 = _mm256_cmp_ps(
+++ _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS),
+++ _CMP_NEQ_UQ);
+++ condition3 = _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, twos), fours)),
+++ fzeroes,
+++ _CMP_NEQ_UQ);
+++
+++ __m256 temp = cosine;
+++ cosine =
+++ _mm256_add_ps(cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1));
+++ sine = _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(temp, sine), condition1));
+++ sine = _mm256_sub_ps(
+++ sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
+++ cosine = _mm256_sub_ps(
+++ cosine,
+++ _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)), condition3));
+++ tangent = _mm256_div_ps(sine, cosine);
+++ _mm256_store_ps(bPtr, tangent);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = tan(*aPtr++);
++ }
++- s = _mm256_div_ps(s, ftwos);
++-
++- sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
++- cosine = _mm256_sub_ps(fones, s);
++-
++- condition1 = _mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)), fzeroes, _CMP_NEQ_UQ);
++- condition2 = _mm256_cmp_ps(_mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS), _CMP_NEQ_UQ);
++- condition3 = _mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, twos), fours)), fzeroes, _CMP_NEQ_UQ);
++-
++- __m256 temp = cosine;
++- cosine = _mm256_add_ps(cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1));
++- sine = _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(temp, sine), condition1));
++- sine = _mm256_sub_ps(sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
++- cosine = _mm256_sub_ps(cosine, _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)), condition3));
++- tangent = _mm256_div_ps(sine, cosine);
++- _mm256_store_ps(bPtr, tangent);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = tan(*aPtr++);
++- }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for aligned */
++@@ -162,78 +186,109 @@ volk_32f_tan_32f_a_avx2_fma(float* bVector, const float* aVector,
++ #include <immintrin.h>
++
++ static inline void
++-volk_32f_tan_32f_a_avx2(float* bVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tan_32f_a_avx2(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- unsigned int i = 0;
++-
++- __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m256 sine, cosine, tangent, condition1, condition2, condition3;
++- __m256i q, r, ones, twos, fours;
++-
++- m4pi = _mm256_set1_ps(1.273239545);
++- pio4A = _mm256_set1_ps(0.78515625);
++- pio4B = _mm256_set1_ps(0.241876e-3);
++- ffours = _mm256_set1_ps(4.0);
++- ftwos = _mm256_set1_ps(2.0);
++- fones = _mm256_set1_ps(1.0);
++- fzeroes = _mm256_setzero_ps();
++- ones = _mm256_set1_epi32(1);
++- twos = _mm256_set1_epi32(2);
++- fours = _mm256_set1_epi32(4);
++-
++- cp1 = _mm256_set1_ps(1.0);
++- cp2 = _mm256_set1_ps(0.83333333e-1);
++- cp3 = _mm256_set1_ps(0.2777778e-2);
++- cp4 = _mm256_set1_ps(0.49603e-4);
++- cp5 = _mm256_set1_ps(0.551e-6);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- s = _mm256_sub_ps(aVal, _mm256_and_ps(_mm256_mul_ps(aVal, ftwos), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
++- q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
++- r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
++-
++- s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4A));
++- s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4B));
++-
++- s = _mm256_div_ps(s, _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm256_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm256_mul_ps(_mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(_mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
++-
++- for(i = 0; i < 3; i++){
++- s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ unsigned int i = 0;
+++
+++ __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones,
+++ fzeroes;
+++ __m256 sine, cosine, tangent, condition1, condition2, condition3;
+++ __m256i q, r, ones, twos, fours;
+++
+++ m4pi = _mm256_set1_ps(1.273239545);
+++ pio4A = _mm256_set1_ps(0.78515625);
+++ pio4B = _mm256_set1_ps(0.241876e-3);
+++ ffours = _mm256_set1_ps(4.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ fones = _mm256_set1_ps(1.0);
+++ fzeroes = _mm256_setzero_ps();
+++ ones = _mm256_set1_epi32(1);
+++ twos = _mm256_set1_epi32(2);
+++ fours = _mm256_set1_epi32(4);
+++
+++ cp1 = _mm256_set1_ps(1.0);
+++ cp2 = _mm256_set1_ps(0.83333333e-1);
+++ cp3 = _mm256_set1_ps(0.2777778e-2);
+++ cp4 = _mm256_set1_ps(0.49603e-4);
+++ cp5 = _mm256_set1_ps(0.551e-6);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ s = _mm256_sub_ps(aVal,
+++ _mm256_and_ps(_mm256_mul_ps(aVal, ftwos),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
+++ q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
+++ r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
+++
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4A));
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4B));
+++
+++ s = _mm256_div_ps(
+++ s,
+++ _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm256_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm256_mul_ps(
+++ _mm256_add_ps(
+++ _mm256_mul_ps(
+++ _mm256_sub_ps(
+++ _mm256_mul_ps(
+++ _mm256_add_ps(
+++ _mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(s, cp5), cp4),
+++ s),
+++ cp3),
+++ s),
+++ cp2),
+++ s),
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++) {
+++ s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ }
+++ s = _mm256_div_ps(s, ftwos);
+++
+++ sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
+++ cosine = _mm256_sub_ps(fones, s);
+++
+++ condition1 = _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)),
+++ fzeroes,
+++ _CMP_NEQ_UQ);
+++ condition2 = _mm256_cmp_ps(
+++ _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS),
+++ _CMP_NEQ_UQ);
+++ condition3 = _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, twos), fours)),
+++ fzeroes,
+++ _CMP_NEQ_UQ);
+++
+++ __m256 temp = cosine;
+++ cosine =
+++ _mm256_add_ps(cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1));
+++ sine = _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(temp, sine), condition1));
+++ sine = _mm256_sub_ps(
+++ sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
+++ cosine = _mm256_sub_ps(
+++ cosine,
+++ _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)), condition3));
+++ tangent = _mm256_div_ps(sine, cosine);
+++ _mm256_store_ps(bPtr, tangent);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = tan(*aPtr++);
++ }
++- s = _mm256_div_ps(s, ftwos);
++-
++- sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
++- cosine = _mm256_sub_ps(fones, s);
++-
++- condition1 = _mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)), fzeroes, _CMP_NEQ_UQ);
++- condition2 = _mm256_cmp_ps(_mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS), _CMP_NEQ_UQ);
++- condition3 = _mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, twos), fours)), fzeroes, _CMP_NEQ_UQ);
++-
++- __m256 temp = cosine;
++- cosine = _mm256_add_ps(cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1));
++- sine = _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(temp, sine), condition1));
++- sine = _mm256_sub_ps(sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
++- cosine = _mm256_sub_ps(cosine, _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)), condition3));
++- tangent = _mm256_div_ps(sine, cosine);
++- _mm256_store_ps(bPtr, tangent);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = tan(*aPtr++);
++- }
++ }
++
++ #endif /* LV_HAVE_AVX2 for aligned */
++@@ -242,78 +297,97 @@ volk_32f_tan_32f_a_avx2(float* bVector, const float* aVector,
++ #include <smmintrin.h>
++
++ static inline void
++-volk_32f_tan_32f_a_sse4_1(float* bVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tan_32f_a_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int quarterPoints = num_points / 4;
++- unsigned int i = 0;
++-
++- __m128 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m128 sine, cosine, tangent, condition1, condition2, condition3;
++- __m128i q, r, ones, twos, fours;
++-
++- m4pi = _mm_set1_ps(1.273239545);
++- pio4A = _mm_set1_ps(0.78515625);
++- pio4B = _mm_set1_ps(0.241876e-3);
++- ffours = _mm_set1_ps(4.0);
++- ftwos = _mm_set1_ps(2.0);
++- fones = _mm_set1_ps(1.0);
++- fzeroes = _mm_setzero_ps();
++- ones = _mm_set1_epi32(1);
++- twos = _mm_set1_epi32(2);
++- fours = _mm_set1_epi32(4);
++-
++- cp1 = _mm_set1_ps(1.0);
++- cp2 = _mm_set1_ps(0.83333333e-1);
++- cp3 = _mm_set1_ps(0.2777778e-2);
++- cp4 = _mm_set1_ps(0.49603e-4);
++- cp5 = _mm_set1_ps(0.551e-6);
++-
++- for(;number < quarterPoints; number++){
++- aVal = _mm_load_ps(aPtr);
++- s = _mm_sub_ps(aVal, _mm_and_ps(_mm_mul_ps(aVal, ftwos), _mm_cmplt_ps(aVal, fzeroes)));
++- q = _mm_cvtps_epi32(_mm_floor_ps(_mm_mul_ps(s, m4pi)));
++- r = _mm_add_epi32(q, _mm_and_si128(q, ones));
++-
++- s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4A));
++- s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4B));
++-
++- s = _mm_div_ps(s, _mm_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
++-
++- for(i = 0; i < 3; i++){
++- s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int quarterPoints = num_points / 4;
+++ unsigned int i = 0;
+++
+++ __m128 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones,
+++ fzeroes;
+++ __m128 sine, cosine, tangent, condition1, condition2, condition3;
+++ __m128i q, r, ones, twos, fours;
+++
+++ m4pi = _mm_set1_ps(1.273239545);
+++ pio4A = _mm_set1_ps(0.78515625);
+++ pio4B = _mm_set1_ps(0.241876e-3);
+++ ffours = _mm_set1_ps(4.0);
+++ ftwos = _mm_set1_ps(2.0);
+++ fones = _mm_set1_ps(1.0);
+++ fzeroes = _mm_setzero_ps();
+++ ones = _mm_set1_epi32(1);
+++ twos = _mm_set1_epi32(2);
+++ fours = _mm_set1_epi32(4);
+++
+++ cp1 = _mm_set1_ps(1.0);
+++ cp2 = _mm_set1_ps(0.83333333e-1);
+++ cp3 = _mm_set1_ps(0.2777778e-2);
+++ cp4 = _mm_set1_ps(0.49603e-4);
+++ cp5 = _mm_set1_ps(0.551e-6);
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
+++ s = _mm_sub_ps(aVal,
+++ _mm_and_ps(_mm_mul_ps(aVal, ftwos), _mm_cmplt_ps(aVal, fzeroes)));
+++ q = _mm_cvtps_epi32(_mm_floor_ps(_mm_mul_ps(s, m4pi)));
+++ r = _mm_add_epi32(q, _mm_and_si128(q, ones));
+++
+++ s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4A));
+++ s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4B));
+++
+++ s = _mm_div_ps(
+++ s, _mm_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm_mul_ps(
+++ _mm_add_ps(
+++ _mm_mul_ps(
+++ _mm_sub_ps(
+++ _mm_mul_ps(
+++ _mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s),
+++ cp3),
+++ s),
+++ cp2),
+++ s),
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++) {
+++ s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
+++ }
+++ s = _mm_div_ps(s, ftwos);
+++
+++ sine = _mm_sqrt_ps(_mm_mul_ps(_mm_sub_ps(ftwos, s), s));
+++ cosine = _mm_sub_ps(fones, s);
+++
+++ condition1 = _mm_cmpneq_ps(
+++ _mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, ones), twos)), fzeroes);
+++ condition2 = _mm_cmpneq_ps(
+++ _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(q, fours)), fzeroes),
+++ _mm_cmplt_ps(aVal, fzeroes));
+++ condition3 = _mm_cmpneq_ps(
+++ _mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, twos), fours)), fzeroes);
+++
+++ __m128 temp = cosine;
+++ cosine = _mm_add_ps(cosine, _mm_and_ps(_mm_sub_ps(sine, cosine), condition1));
+++ sine = _mm_add_ps(sine, _mm_and_ps(_mm_sub_ps(temp, sine), condition1));
+++ sine =
+++ _mm_sub_ps(sine, _mm_and_ps(_mm_mul_ps(sine, _mm_set1_ps(2.0f)), condition2));
+++ cosine = _mm_sub_ps(
+++ cosine, _mm_and_ps(_mm_mul_ps(cosine, _mm_set1_ps(2.0f)), condition3));
+++ tangent = _mm_div_ps(sine, cosine);
+++ _mm_store_ps(bPtr, tangent);
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = tanf(*aPtr++);
++ }
++- s = _mm_div_ps(s, ftwos);
++-
++- sine = _mm_sqrt_ps(_mm_mul_ps(_mm_sub_ps(ftwos, s), s));
++- cosine = _mm_sub_ps(fones, s);
++-
++- condition1 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, ones), twos)), fzeroes);
++- condition2 = _mm_cmpneq_ps(_mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(q, fours)), fzeroes), _mm_cmplt_ps(aVal, fzeroes));
++- condition3 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, twos), fours)), fzeroes);
++-
++- __m128 temp = cosine;
++- cosine = _mm_add_ps(cosine, _mm_and_ps(_mm_sub_ps(sine, cosine), condition1));
++- sine = _mm_add_ps(sine, _mm_and_ps(_mm_sub_ps(temp, sine), condition1));
++- sine = _mm_sub_ps(sine, _mm_and_ps(_mm_mul_ps(sine, _mm_set1_ps(2.0f)), condition2));
++- cosine = _mm_sub_ps(cosine, _mm_and_ps(_mm_mul_ps(cosine, _mm_set1_ps(2.0f)), condition3));
++- tangent = _mm_div_ps(sine, cosine);
++- _mm_store_ps(bPtr, tangent);
++- aPtr += 4;
++- bPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *bPtr++ = tanf(*aPtr++);
++- }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for aligned */
++@@ -328,78 +402,102 @@ volk_32f_tan_32f_a_sse4_1(float* bVector, const float* aVector,
++ #include <immintrin.h>
++
++ static inline void
++-volk_32f_tan_32f_u_avx2_fma(float* bVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tan_32f_u_avx2_fma(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- unsigned int i = 0;
++-
++- __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m256 sine, cosine, tangent, condition1, condition2, condition3;
++- __m256i q, r, ones, twos, fours;
++-
++- m4pi = _mm256_set1_ps(1.273239545);
++- pio4A = _mm256_set1_ps(0.78515625);
++- pio4B = _mm256_set1_ps(0.241876e-3);
++- ffours = _mm256_set1_ps(4.0);
++- ftwos = _mm256_set1_ps(2.0);
++- fones = _mm256_set1_ps(1.0);
++- fzeroes = _mm256_setzero_ps();
++- ones = _mm256_set1_epi32(1);
++- twos = _mm256_set1_epi32(2);
++- fours = _mm256_set1_epi32(4);
++-
++- cp1 = _mm256_set1_ps(1.0);
++- cp2 = _mm256_set1_ps(0.83333333e-1);
++- cp3 = _mm256_set1_ps(0.2777778e-2);
++- cp4 = _mm256_set1_ps(0.49603e-4);
++- cp5 = _mm256_set1_ps(0.551e-6);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- s = _mm256_sub_ps(aVal, _mm256_and_ps(_mm256_mul_ps(aVal, ftwos), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
++- q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
++- r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
++-
++- s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4A, s);
++- s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4B, s);
++-
++- s = _mm256_div_ps(s, _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm256_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm256_mul_ps(_mm256_fmadd_ps(_mm256_fmsub_ps(_mm256_fmadd_ps(_mm256_fmsub_ps(s, cp5, cp4), s, cp3), s, cp2), s, cp1), s);
++-
++- for(i = 0; i < 3; i++){
++- s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ unsigned int i = 0;
+++
+++ __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones,
+++ fzeroes;
+++ __m256 sine, cosine, tangent, condition1, condition2, condition3;
+++ __m256i q, r, ones, twos, fours;
+++
+++ m4pi = _mm256_set1_ps(1.273239545);
+++ pio4A = _mm256_set1_ps(0.78515625);
+++ pio4B = _mm256_set1_ps(0.241876e-3);
+++ ffours = _mm256_set1_ps(4.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ fones = _mm256_set1_ps(1.0);
+++ fzeroes = _mm256_setzero_ps();
+++ ones = _mm256_set1_epi32(1);
+++ twos = _mm256_set1_epi32(2);
+++ fours = _mm256_set1_epi32(4);
+++
+++ cp1 = _mm256_set1_ps(1.0);
+++ cp2 = _mm256_set1_ps(0.83333333e-1);
+++ cp3 = _mm256_set1_ps(0.2777778e-2);
+++ cp4 = _mm256_set1_ps(0.49603e-4);
+++ cp5 = _mm256_set1_ps(0.551e-6);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ s = _mm256_sub_ps(aVal,
+++ _mm256_and_ps(_mm256_mul_ps(aVal, ftwos),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
+++ q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
+++ r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
+++
+++ s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4A, s);
+++ s = _mm256_fnmadd_ps(_mm256_cvtepi32_ps(r), pio4B, s);
+++
+++ s = _mm256_div_ps(
+++ s,
+++ _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm256_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm256_mul_ps(
+++ _mm256_fmadd_ps(
+++ _mm256_fmsub_ps(
+++ _mm256_fmadd_ps(_mm256_fmsub_ps(s, cp5, cp4), s, cp3), s, cp2),
+++ s,
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++) {
+++ s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ }
+++ s = _mm256_div_ps(s, ftwos);
+++
+++ sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
+++ cosine = _mm256_sub_ps(fones, s);
+++
+++ condition1 = _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)),
+++ fzeroes,
+++ _CMP_NEQ_UQ);
+++ condition2 = _mm256_cmp_ps(
+++ _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS),
+++ _CMP_NEQ_UQ);
+++ condition3 = _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, twos), fours)),
+++ fzeroes,
+++ _CMP_NEQ_UQ);
+++
+++ __m256 temp = cosine;
+++ cosine =
+++ _mm256_add_ps(cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1));
+++ sine = _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(temp, sine), condition1));
+++ sine = _mm256_sub_ps(
+++ sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
+++ cosine = _mm256_sub_ps(
+++ cosine,
+++ _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)), condition3));
+++ tangent = _mm256_div_ps(sine, cosine);
+++ _mm256_storeu_ps(bPtr, tangent);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = tan(*aPtr++);
++ }
++- s = _mm256_div_ps(s, ftwos);
++-
++- sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
++- cosine = _mm256_sub_ps(fones, s);
++-
++- condition1 = _mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)), fzeroes, _CMP_NEQ_UQ);
++- condition2 = _mm256_cmp_ps(_mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS), _CMP_NEQ_UQ);
++- condition3 = _mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, twos), fours)), fzeroes, _CMP_NEQ_UQ);
++-
++- __m256 temp = cosine;
++- cosine = _mm256_add_ps(cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1));
++- sine = _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(temp, sine), condition1));
++- sine = _mm256_sub_ps(sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
++- cosine = _mm256_sub_ps(cosine, _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)), condition3));
++- tangent = _mm256_div_ps(sine, cosine);
++- _mm256_storeu_ps(bPtr, tangent);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = tan(*aPtr++);
++- }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for unaligned */
++@@ -408,78 +506,109 @@ volk_32f_tan_32f_u_avx2_fma(float* bVector, const float* aVector,
++ #include <immintrin.h>
++
++ static inline void
++-volk_32f_tan_32f_u_avx2(float* bVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tan_32f_u_avx2(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int eighthPoints = num_points / 8;
++- unsigned int i = 0;
++-
++- __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m256 sine, cosine, tangent, condition1, condition2, condition3;
++- __m256i q, r, ones, twos, fours;
++-
++- m4pi = _mm256_set1_ps(1.273239545);
++- pio4A = _mm256_set1_ps(0.78515625);
++- pio4B = _mm256_set1_ps(0.241876e-3);
++- ffours = _mm256_set1_ps(4.0);
++- ftwos = _mm256_set1_ps(2.0);
++- fones = _mm256_set1_ps(1.0);
++- fzeroes = _mm256_setzero_ps();
++- ones = _mm256_set1_epi32(1);
++- twos = _mm256_set1_epi32(2);
++- fours = _mm256_set1_epi32(4);
++-
++- cp1 = _mm256_set1_ps(1.0);
++- cp2 = _mm256_set1_ps(0.83333333e-1);
++- cp3 = _mm256_set1_ps(0.2777778e-2);
++- cp4 = _mm256_set1_ps(0.49603e-4);
++- cp5 = _mm256_set1_ps(0.551e-6);
++-
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- s = _mm256_sub_ps(aVal, _mm256_and_ps(_mm256_mul_ps(aVal, ftwos), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
++- q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
++- r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
++-
++- s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4A));
++- s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4B));
++-
++- s = _mm256_div_ps(s, _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm256_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm256_mul_ps(_mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(_mm256_add_ps(_mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
++-
++- for(i = 0; i < 3; i++){
++- s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int eighthPoints = num_points / 8;
+++ unsigned int i = 0;
+++
+++ __m256 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones,
+++ fzeroes;
+++ __m256 sine, cosine, tangent, condition1, condition2, condition3;
+++ __m256i q, r, ones, twos, fours;
+++
+++ m4pi = _mm256_set1_ps(1.273239545);
+++ pio4A = _mm256_set1_ps(0.78515625);
+++ pio4B = _mm256_set1_ps(0.241876e-3);
+++ ffours = _mm256_set1_ps(4.0);
+++ ftwos = _mm256_set1_ps(2.0);
+++ fones = _mm256_set1_ps(1.0);
+++ fzeroes = _mm256_setzero_ps();
+++ ones = _mm256_set1_epi32(1);
+++ twos = _mm256_set1_epi32(2);
+++ fours = _mm256_set1_epi32(4);
+++
+++ cp1 = _mm256_set1_ps(1.0);
+++ cp2 = _mm256_set1_ps(0.83333333e-1);
+++ cp3 = _mm256_set1_ps(0.2777778e-2);
+++ cp4 = _mm256_set1_ps(0.49603e-4);
+++ cp5 = _mm256_set1_ps(0.551e-6);
+++
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ s = _mm256_sub_ps(aVal,
+++ _mm256_and_ps(_mm256_mul_ps(aVal, ftwos),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS)));
+++ q = _mm256_cvtps_epi32(_mm256_floor_ps(_mm256_mul_ps(s, m4pi)));
+++ r = _mm256_add_epi32(q, _mm256_and_si256(q, ones));
+++
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4A));
+++ s = _mm256_sub_ps(s, _mm256_mul_ps(_mm256_cvtepi32_ps(r), pio4B));
+++
+++ s = _mm256_div_ps(
+++ s,
+++ _mm256_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm256_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm256_mul_ps(
+++ _mm256_add_ps(
+++ _mm256_mul_ps(
+++ _mm256_sub_ps(
+++ _mm256_mul_ps(
+++ _mm256_add_ps(
+++ _mm256_mul_ps(_mm256_sub_ps(_mm256_mul_ps(s, cp5), cp4),
+++ s),
+++ cp3),
+++ s),
+++ cp2),
+++ s),
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++) {
+++ s = _mm256_mul_ps(s, _mm256_sub_ps(ffours, s));
+++ }
+++ s = _mm256_div_ps(s, ftwos);
+++
+++ sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
+++ cosine = _mm256_sub_ps(fones, s);
+++
+++ condition1 = _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)),
+++ fzeroes,
+++ _CMP_NEQ_UQ);
+++ condition2 = _mm256_cmp_ps(
+++ _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ),
+++ _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS),
+++ _CMP_NEQ_UQ);
+++ condition3 = _mm256_cmp_ps(
+++ _mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, twos), fours)),
+++ fzeroes,
+++ _CMP_NEQ_UQ);
+++
+++ __m256 temp = cosine;
+++ cosine =
+++ _mm256_add_ps(cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1));
+++ sine = _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(temp, sine), condition1));
+++ sine = _mm256_sub_ps(
+++ sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
+++ cosine = _mm256_sub_ps(
+++ cosine,
+++ _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)), condition3));
+++ tangent = _mm256_div_ps(sine, cosine);
+++ _mm256_storeu_ps(bPtr, tangent);
+++ aPtr += 8;
+++ bPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = tan(*aPtr++);
++ }
++- s = _mm256_div_ps(s, ftwos);
++-
++- sine = _mm256_sqrt_ps(_mm256_mul_ps(_mm256_sub_ps(ftwos, s), s));
++- cosine = _mm256_sub_ps(fones, s);
++-
++- condition1 = _mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, ones), twos)), fzeroes, _CMP_NEQ_UQ);
++- condition2 = _mm256_cmp_ps(_mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(q, fours)), fzeroes, _CMP_NEQ_UQ), _mm256_cmp_ps(aVal, fzeroes, _CMP_LT_OS), _CMP_NEQ_UQ);
++- condition3 = _mm256_cmp_ps(_mm256_cvtepi32_ps(_mm256_and_si256(_mm256_add_epi32(q, twos), fours)), fzeroes, _CMP_NEQ_UQ);
++-
++- __m256 temp = cosine;
++- cosine = _mm256_add_ps(cosine, _mm256_and_ps(_mm256_sub_ps(sine, cosine), condition1));
++- sine = _mm256_add_ps(sine, _mm256_and_ps(_mm256_sub_ps(temp, sine), condition1));
++- sine = _mm256_sub_ps(sine, _mm256_and_ps(_mm256_mul_ps(sine, _mm256_set1_ps(2.0f)), condition2));
++- cosine = _mm256_sub_ps(cosine, _mm256_and_ps(_mm256_mul_ps(cosine, _mm256_set1_ps(2.0f)), condition3));
++- tangent = _mm256_div_ps(sine, cosine);
++- _mm256_storeu_ps(bPtr, tangent);
++- aPtr += 8;
++- bPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *bPtr++ = tan(*aPtr++);
++- }
++ }
++
++ #endif /* LV_HAVE_AVX2 for unaligned */
++@@ -491,75 +620,95 @@ volk_32f_tan_32f_u_avx2(float* bVector, const float* aVector,
++ static inline void
++ volk_32f_tan_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- unsigned int quarterPoints = num_points / 4;
++- unsigned int i = 0;
++-
++- __m128 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones, fzeroes;
++- __m128 sine, cosine, tangent, condition1, condition2, condition3;
++- __m128i q, r, ones, twos, fours;
++-
++- m4pi = _mm_set1_ps(1.273239545);
++- pio4A = _mm_set1_ps(0.78515625);
++- pio4B = _mm_set1_ps(0.241876e-3);
++- ffours = _mm_set1_ps(4.0);
++- ftwos = _mm_set1_ps(2.0);
++- fones = _mm_set1_ps(1.0);
++- fzeroes = _mm_setzero_ps();
++- ones = _mm_set1_epi32(1);
++- twos = _mm_set1_epi32(2);
++- fours = _mm_set1_epi32(4);
++-
++- cp1 = _mm_set1_ps(1.0);
++- cp2 = _mm_set1_ps(0.83333333e-1);
++- cp3 = _mm_set1_ps(0.2777778e-2);
++- cp4 = _mm_set1_ps(0.49603e-4);
++- cp5 = _mm_set1_ps(0.551e-6);
++-
++- for(;number < quarterPoints; number++){
++- aVal = _mm_loadu_ps(aPtr);
++- s = _mm_sub_ps(aVal, _mm_and_ps(_mm_mul_ps(aVal, ftwos), _mm_cmplt_ps(aVal, fzeroes)));
++- q = _mm_cvtps_epi32(_mm_floor_ps(_mm_mul_ps(s, m4pi)));
++- r = _mm_add_epi32(q, _mm_and_si128(q, ones));
++-
++- s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4A));
++- s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4B));
++-
++- s = _mm_div_ps(s, _mm_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
++- s = _mm_mul_ps(s, s);
++- // Evaluate Taylor series
++- s = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s), cp3), s), cp2), s), cp1), s);
++-
++- for(i = 0; i < 3; i++){
++- s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ unsigned int quarterPoints = num_points / 4;
+++ unsigned int i = 0;
+++
+++ __m128 aVal, s, m4pi, pio4A, pio4B, cp1, cp2, cp3, cp4, cp5, ffours, ftwos, fones,
+++ fzeroes;
+++ __m128 sine, cosine, tangent, condition1, condition2, condition3;
+++ __m128i q, r, ones, twos, fours;
+++
+++ m4pi = _mm_set1_ps(1.273239545);
+++ pio4A = _mm_set1_ps(0.78515625);
+++ pio4B = _mm_set1_ps(0.241876e-3);
+++ ffours = _mm_set1_ps(4.0);
+++ ftwos = _mm_set1_ps(2.0);
+++ fones = _mm_set1_ps(1.0);
+++ fzeroes = _mm_setzero_ps();
+++ ones = _mm_set1_epi32(1);
+++ twos = _mm_set1_epi32(2);
+++ fours = _mm_set1_epi32(4);
+++
+++ cp1 = _mm_set1_ps(1.0);
+++ cp2 = _mm_set1_ps(0.83333333e-1);
+++ cp3 = _mm_set1_ps(0.2777778e-2);
+++ cp4 = _mm_set1_ps(0.49603e-4);
+++ cp5 = _mm_set1_ps(0.551e-6);
+++
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_loadu_ps(aPtr);
+++ s = _mm_sub_ps(aVal,
+++ _mm_and_ps(_mm_mul_ps(aVal, ftwos), _mm_cmplt_ps(aVal, fzeroes)));
+++ q = _mm_cvtps_epi32(_mm_floor_ps(_mm_mul_ps(s, m4pi)));
+++ r = _mm_add_epi32(q, _mm_and_si128(q, ones));
+++
+++ s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4A));
+++ s = _mm_sub_ps(s, _mm_mul_ps(_mm_cvtepi32_ps(r), pio4B));
+++
+++ s = _mm_div_ps(
+++ s, _mm_set1_ps(8.0)); // The constant is 2^N, for 3 times argument reduction
+++ s = _mm_mul_ps(s, s);
+++ // Evaluate Taylor series
+++ s = _mm_mul_ps(
+++ _mm_add_ps(
+++ _mm_mul_ps(
+++ _mm_sub_ps(
+++ _mm_mul_ps(
+++ _mm_add_ps(_mm_mul_ps(_mm_sub_ps(_mm_mul_ps(s, cp5), cp4), s),
+++ cp3),
+++ s),
+++ cp2),
+++ s),
+++ cp1),
+++ s);
+++
+++ for (i = 0; i < 3; i++) {
+++ s = _mm_mul_ps(s, _mm_sub_ps(ffours, s));
+++ }
+++ s = _mm_div_ps(s, ftwos);
+++
+++ sine = _mm_sqrt_ps(_mm_mul_ps(_mm_sub_ps(ftwos, s), s));
+++ cosine = _mm_sub_ps(fones, s);
+++
+++ condition1 = _mm_cmpneq_ps(
+++ _mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, ones), twos)), fzeroes);
+++ condition2 = _mm_cmpneq_ps(
+++ _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(q, fours)), fzeroes),
+++ _mm_cmplt_ps(aVal, fzeroes));
+++ condition3 = _mm_cmpneq_ps(
+++ _mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, twos), fours)), fzeroes);
+++
+++ __m128 temp = cosine;
+++ cosine = _mm_add_ps(cosine, _mm_and_ps(_mm_sub_ps(sine, cosine), condition1));
+++ sine = _mm_add_ps(sine, _mm_and_ps(_mm_sub_ps(temp, sine), condition1));
+++ sine =
+++ _mm_sub_ps(sine, _mm_and_ps(_mm_mul_ps(sine, _mm_set1_ps(2.0f)), condition2));
+++ cosine = _mm_sub_ps(
+++ cosine, _mm_and_ps(_mm_mul_ps(cosine, _mm_set1_ps(2.0f)), condition3));
+++ tangent = _mm_div_ps(sine, cosine);
+++ _mm_storeu_ps(bPtr, tangent);
+++ aPtr += 4;
+++ bPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *bPtr++ = tanf(*aPtr++);
++ }
++- s = _mm_div_ps(s, ftwos);
++-
++- sine = _mm_sqrt_ps(_mm_mul_ps(_mm_sub_ps(ftwos, s), s));
++- cosine = _mm_sub_ps(fones, s);
++-
++- condition1 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, ones), twos)), fzeroes);
++- condition2 = _mm_cmpneq_ps(_mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(q, fours)), fzeroes), _mm_cmplt_ps(aVal, fzeroes));
++- condition3 = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mm_and_si128(_mm_add_epi32(q, twos), fours)), fzeroes);
++-
++- __m128 temp = cosine;
++- cosine = _mm_add_ps(cosine, _mm_and_ps(_mm_sub_ps(sine, cosine), condition1));
++- sine = _mm_add_ps(sine, _mm_and_ps(_mm_sub_ps(temp, sine), condition1));
++- sine = _mm_sub_ps(sine, _mm_and_ps(_mm_mul_ps(sine, _mm_set1_ps(2.0f)), condition2));
++- cosine = _mm_sub_ps(cosine, _mm_and_ps(_mm_mul_ps(cosine, _mm_set1_ps(2.0f)), condition3));
++- tangent = _mm_div_ps(sine, cosine);
++- _mm_storeu_ps(bPtr, tangent);
++- aPtr += 4;
++- bPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *bPtr++ = tanf(*aPtr++);
++- }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for unaligned */
++@@ -568,16 +717,15 @@ volk_32f_tan_32f_u_sse4_1(float* bVector, const float* aVector, unsigned int num
++ #ifdef LV_HAVE_GENERIC
++
++ static inline void
++-volk_32f_tan_32f_generic(float* bVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tan_32f_generic(float* bVector, const float* aVector, unsigned int num_points)
++ {
++- float* bPtr = bVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
+++ float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(; number < num_points; number++){
++- *bPtr++ = tanf(*aPtr++);
++- }
+++ for (; number < num_points; number++) {
+++ *bPtr++ = tanf(*aPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -587,30 +735,29 @@ volk_32f_tan_32f_generic(float* bVector, const float* aVector,
++ #include <volk/volk_neon_intrinsics.h>
++
++ static inline void
++-volk_32f_tan_32f_neon(float* bVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tan_32f_neon(float* bVector, const float* aVector, unsigned int num_points)
++ {
++ unsigned int number = 0;
++ unsigned int quarter_points = num_points / 4;
++ float* bVectorPtr = bVector;
++ const float* aVectorPtr = aVector;
++-
+++
++ float32x4_t b_vec;
++ float32x4_t a_vec;
++-
++- for(number = 0; number < quarter_points; number++) {
+++
+++ for (number = 0; number < quarter_points; number++) {
++ a_vec = vld1q_f32(aVectorPtr);
++ // Prefetch next one, speeds things up
++- __VOLK_PREFETCH(aVectorPtr+4);
+++ __VOLK_PREFETCH(aVectorPtr + 4);
++ b_vec = _vtanq_f32(a_vec);
++ vst1q_f32(bVectorPtr, b_vec);
++ // move pointers ahead
++- bVectorPtr+=4;
++- aVectorPtr+=4;
+++ bVectorPtr += 4;
+++ aVectorPtr += 4;
++ }
++-
+++
++ // Deal with the rest
++- for(number = quarter_points * 4; number < num_points; number++) {
+++ for (number = quarter_points * 4; number < num_points; number++) {
++ *bVectorPtr++ = tanf(*aVectorPtr++);
++ }
++ }
++diff --git a/kernels/volk/volk_32f_tanh_32f.h b/kernels/volk/volk_32f_tanh_32f.h
++index d49432d..f157d39 100644
++--- a/kernels/volk/volk_32f_tanh_32f.h
+++++ b/kernels/volk/volk_32f_tanh_32f.h
++@@ -69,22 +69,21 @@
++ #define INCLUDED_volk_32f_tanh_32f_a_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++ #include <string.h>
++
++ #ifdef LV_HAVE_GENERIC
++
++ static inline void
++-volk_32f_tanh_32f_generic(float* cVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tanh_32f_generic(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- for(; number < num_points; number++) {
++- *cPtr++ = tanhf(*aPtr++);
++- }
+++ unsigned int number = 0;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = tanhf(*aPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -93,81 +92,88 @@ volk_32f_tanh_32f_generic(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_GENERIC
++
++ static inline void
++-volk_32f_tanh_32f_series(float* cVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tanh_32f_series(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- for(; number < num_points; number++) {
++- if(*aPtr > 4.97)
++- *cPtr++ = 1;
++- else if(*aPtr <= -4.97)
++- *cPtr++ = -1;
++- else {
++- float x2 = (*aPtr) * (*aPtr);
++- float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
++- float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
++- *cPtr++ = a / b;
++- aPtr++;
+++ unsigned int number = 0;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ for (; number < num_points; number++) {
+++ if (*aPtr > 4.97)
+++ *cPtr++ = 1;
+++ else if (*aPtr <= -4.97)
+++ *cPtr++ = -1;
+++ else {
+++ float x2 = (*aPtr) * (*aPtr);
+++ float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
+++ float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
+++ *cPtr++ = a / b;
+++ aPtr++;
+++ }
++ }
++- }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++ static inline void
++-volk_32f_tanh_32f_a_sse(float* cVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tanh_32f_a_sse(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++-
++- __m128 aVal, cVal, x2, a, b;
++- __m128 const1, const2, const3, const4, const5, const6;
++- const1 = _mm_set_ps1(135135.0f);
++- const2 = _mm_set_ps1(17325.0f);
++- const3 = _mm_set_ps1(378.0f);
++- const4 = _mm_set_ps1(62370.0f);
++- const5 = _mm_set_ps1(3150.0f);
++- const6 = _mm_set_ps1(28.0f);
++- for(;number < quarterPoints; number++){
++-
++- aVal = _mm_load_ps(aPtr);
++- x2 = _mm_mul_ps(aVal, aVal);
++- a = _mm_mul_ps(aVal, _mm_add_ps(const1, _mm_mul_ps(x2, _mm_add_ps(const2, _mm_mul_ps(x2, _mm_add_ps(const3, x2))))));
++- b = _mm_add_ps(const1, _mm_mul_ps(x2, _mm_add_ps(const4, _mm_mul_ps(x2, _mm_add_ps(const5, _mm_mul_ps(x2, const6))))));
++-
++- cVal = _mm_div_ps(a, b);
++-
++- _mm_store_ps(cPtr, cVal); // Store the results back into the C container
++-
++- aPtr += 4;
++- cPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++) {
++- if(*aPtr > 4.97)
++- *cPtr++ = 1;
++- else if(*aPtr <= -4.97)
++- *cPtr++ = -1;
++- else {
++- float x2 = (*aPtr) * (*aPtr);
++- float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
++- float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
++- *cPtr++ = a / b;
++- aPtr++;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++
+++ __m128 aVal, cVal, x2, a, b;
+++ __m128 const1, const2, const3, const4, const5, const6;
+++ const1 = _mm_set_ps1(135135.0f);
+++ const2 = _mm_set_ps1(17325.0f);
+++ const3 = _mm_set_ps1(378.0f);
+++ const4 = _mm_set_ps1(62370.0f);
+++ const5 = _mm_set_ps1(3150.0f);
+++ const6 = _mm_set_ps1(28.0f);
+++ for (; number < quarterPoints; number++) {
+++
+++ aVal = _mm_load_ps(aPtr);
+++ x2 = _mm_mul_ps(aVal, aVal);
+++ a = _mm_mul_ps(
+++ aVal,
+++ _mm_add_ps(
+++ const1,
+++ _mm_mul_ps(x2,
+++ _mm_add_ps(const2, _mm_mul_ps(x2, _mm_add_ps(const3, x2))))));
+++ b = _mm_add_ps(
+++ const1,
+++ _mm_mul_ps(
+++ x2,
+++ _mm_add_ps(const4,
+++ _mm_mul_ps(x2, _mm_add_ps(const5, _mm_mul_ps(x2, const6))))));
+++
+++ cVal = _mm_div_ps(a, b);
+++
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
+++
+++ aPtr += 4;
+++ cPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ if (*aPtr > 4.97)
+++ *cPtr++ = 1;
+++ else if (*aPtr <= -4.97)
+++ *cPtr++ = -1;
+++ else {
+++ float x2 = (*aPtr) * (*aPtr);
+++ float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
+++ float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
+++ *cPtr++ = a / b;
+++ aPtr++;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -176,52 +182,65 @@ volk_32f_tanh_32f_a_sse(float* cVector, const float* aVector,
++ #include <immintrin.h>
++
++ static inline void
++-volk_32f_tanh_32f_a_avx(float* cVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tanh_32f_a_avx(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++-
++- __m256 aVal, cVal, x2, a, b;
++- __m256 const1, const2, const3, const4, const5, const6;
++- const1 = _mm256_set1_ps(135135.0f);
++- const2 = _mm256_set1_ps(17325.0f);
++- const3 = _mm256_set1_ps(378.0f);
++- const4 = _mm256_set1_ps(62370.0f);
++- const5 = _mm256_set1_ps(3150.0f);
++- const6 = _mm256_set1_ps(28.0f);
++- for(;number < eighthPoints; number++){
++-
++- aVal = _mm256_load_ps(aPtr);
++- x2 = _mm256_mul_ps(aVal, aVal);
++- a = _mm256_mul_ps(aVal, _mm256_add_ps(const1, _mm256_mul_ps(x2, _mm256_add_ps(const2, _mm256_mul_ps(x2, _mm256_add_ps(const3, x2))))));
++- b = _mm256_add_ps(const1, _mm256_mul_ps(x2, _mm256_add_ps(const4, _mm256_mul_ps(x2, _mm256_add_ps(const5, _mm256_mul_ps(x2, const6))))));
++-
++- cVal = _mm256_div_ps(a, b);
++-
++- _mm256_store_ps(cPtr, cVal); // Store the results back into the C container
++-
++- aPtr += 8;
++- cPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++) {
++- if(*aPtr > 4.97)
++- *cPtr++ = 1;
++- else if(*aPtr <= -4.97)
++- *cPtr++ = -1;
++- else {
++- float x2 = (*aPtr) * (*aPtr);
++- float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
++- float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
++- *cPtr++ = a / b;
++- aPtr++;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++
+++ __m256 aVal, cVal, x2, a, b;
+++ __m256 const1, const2, const3, const4, const5, const6;
+++ const1 = _mm256_set1_ps(135135.0f);
+++ const2 = _mm256_set1_ps(17325.0f);
+++ const3 = _mm256_set1_ps(378.0f);
+++ const4 = _mm256_set1_ps(62370.0f);
+++ const5 = _mm256_set1_ps(3150.0f);
+++ const6 = _mm256_set1_ps(28.0f);
+++ for (; number < eighthPoints; number++) {
+++
+++ aVal = _mm256_load_ps(aPtr);
+++ x2 = _mm256_mul_ps(aVal, aVal);
+++ a = _mm256_mul_ps(
+++ aVal,
+++ _mm256_add_ps(
+++ const1,
+++ _mm256_mul_ps(
+++ x2,
+++ _mm256_add_ps(const2,
+++ _mm256_mul_ps(x2, _mm256_add_ps(const3, x2))))));
+++ b = _mm256_add_ps(
+++ const1,
+++ _mm256_mul_ps(
+++ x2,
+++ _mm256_add_ps(
+++ const4,
+++ _mm256_mul_ps(x2,
+++ _mm256_add_ps(const5, _mm256_mul_ps(x2, const6))))));
+++
+++ cVal = _mm256_div_ps(a, b);
+++
+++ _mm256_store_ps(cPtr, cVal); // Store the results back into the C container
+++
+++ aPtr += 8;
+++ cPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ if (*aPtr > 4.97)
+++ *cPtr++ = 1;
+++ else if (*aPtr <= -4.97)
+++ *cPtr++ = -1;
+++ else {
+++ float x2 = (*aPtr) * (*aPtr);
+++ float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
+++ float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
+++ *cPtr++ = a / b;
+++ aPtr++;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -229,52 +248,55 @@ volk_32f_tanh_32f_a_avx(float* cVector, const float* aVector,
++ #include <immintrin.h>
++
++ static inline void
++-volk_32f_tanh_32f_a_avx_fma(float* cVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tanh_32f_a_avx_fma(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++-
++- __m256 aVal, cVal, x2, a, b;
++- __m256 const1, const2, const3, const4, const5, const6;
++- const1 = _mm256_set1_ps(135135.0f);
++- const2 = _mm256_set1_ps(17325.0f);
++- const3 = _mm256_set1_ps(378.0f);
++- const4 = _mm256_set1_ps(62370.0f);
++- const5 = _mm256_set1_ps(3150.0f);
++- const6 = _mm256_set1_ps(28.0f);
++- for(;number < eighthPoints; number++){
++-
++- aVal = _mm256_load_ps(aPtr);
++- x2 = _mm256_mul_ps(aVal, aVal);
++- a = _mm256_mul_ps(aVal, _mm256_fmadd_ps(x2, _mm256_fmadd_ps(x2, _mm256_add_ps(const3, x2), const2),const1));
++- b = _mm256_fmadd_ps(x2, _mm256_fmadd_ps(x2, _mm256_fmadd_ps(x2, const6, const5), const4), const1);
++-
++- cVal = _mm256_div_ps(a, b);
++-
++- _mm256_store_ps(cPtr, cVal); // Store the results back into the C container
++-
++- aPtr += 8;
++- cPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++) {
++- if(*aPtr > 4.97)
++- *cPtr++ = 1;
++- else if(*aPtr <= -4.97)
++- *cPtr++ = -1;
++- else {
++- float x2 = (*aPtr) * (*aPtr);
++- float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
++- float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
++- *cPtr++ = a / b;
++- aPtr++;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++
+++ __m256 aVal, cVal, x2, a, b;
+++ __m256 const1, const2, const3, const4, const5, const6;
+++ const1 = _mm256_set1_ps(135135.0f);
+++ const2 = _mm256_set1_ps(17325.0f);
+++ const3 = _mm256_set1_ps(378.0f);
+++ const4 = _mm256_set1_ps(62370.0f);
+++ const5 = _mm256_set1_ps(3150.0f);
+++ const6 = _mm256_set1_ps(28.0f);
+++ for (; number < eighthPoints; number++) {
+++
+++ aVal = _mm256_load_ps(aPtr);
+++ x2 = _mm256_mul_ps(aVal, aVal);
+++ a = _mm256_mul_ps(
+++ aVal,
+++ _mm256_fmadd_ps(
+++ x2, _mm256_fmadd_ps(x2, _mm256_add_ps(const3, x2), const2), const1));
+++ b = _mm256_fmadd_ps(
+++ x2, _mm256_fmadd_ps(x2, _mm256_fmadd_ps(x2, const6, const5), const4), const1);
+++
+++ cVal = _mm256_div_ps(a, b);
+++
+++ _mm256_store_ps(cPtr, cVal); // Store the results back into the C container
+++
+++ aPtr += 8;
+++ cPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ if (*aPtr > 4.97)
+++ *cPtr++ = 1;
+++ else if (*aPtr <= -4.97)
+++ *cPtr++ = -1;
+++ else {
+++ float x2 = (*aPtr) * (*aPtr);
+++ float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
+++ float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
+++ *cPtr++ = a / b;
+++ aPtr++;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_AVX && LV_HAVE_FMA */
++
++@@ -285,8 +307,8 @@ volk_32f_tanh_32f_a_avx_fma(float* cVector, const float* aVector,
++ #define INCLUDED_volk_32f_tanh_32f_u_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++ #include <string.h>
++
++
++@@ -294,52 +316,61 @@ volk_32f_tanh_32f_a_avx_fma(float* cVector, const float* aVector,
++ #include <xmmintrin.h>
++
++ static inline void
++-volk_32f_tanh_32f_u_sse(float* cVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tanh_32f_u_sse(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++-
++- __m128 aVal, cVal, x2, a, b;
++- __m128 const1, const2, const3, const4, const5, const6;
++- const1 = _mm_set_ps1(135135.0f);
++- const2 = _mm_set_ps1(17325.0f);
++- const3 = _mm_set_ps1(378.0f);
++- const4 = _mm_set_ps1(62370.0f);
++- const5 = _mm_set_ps1(3150.0f);
++- const6 = _mm_set_ps1(28.0f);
++- for(;number < quarterPoints; number++){
++-
++- aVal = _mm_loadu_ps(aPtr);
++- x2 = _mm_mul_ps(aVal, aVal);
++- a = _mm_mul_ps(aVal, _mm_add_ps(const1, _mm_mul_ps(x2, _mm_add_ps(const2, _mm_mul_ps(x2, _mm_add_ps(const3, x2))))));
++- b = _mm_add_ps(const1, _mm_mul_ps(x2, _mm_add_ps(const4, _mm_mul_ps(x2, _mm_add_ps(const5, _mm_mul_ps(x2, const6))))));
++-
++- cVal = _mm_div_ps(a, b);
++-
++- _mm_storeu_ps(cPtr, cVal); // Store the results back into the C container
++-
++- aPtr += 4;
++- cPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(;number < num_points; number++) {
++- if(*aPtr > 4.97)
++- *cPtr++ = 1;
++- else if(*aPtr <= -4.97)
++- *cPtr++ = -1;
++- else {
++- float x2 = (*aPtr) * (*aPtr);
++- float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
++- float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
++- *cPtr++ = a / b;
++- aPtr++;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++
+++ __m128 aVal, cVal, x2, a, b;
+++ __m128 const1, const2, const3, const4, const5, const6;
+++ const1 = _mm_set_ps1(135135.0f);
+++ const2 = _mm_set_ps1(17325.0f);
+++ const3 = _mm_set_ps1(378.0f);
+++ const4 = _mm_set_ps1(62370.0f);
+++ const5 = _mm_set_ps1(3150.0f);
+++ const6 = _mm_set_ps1(28.0f);
+++ for (; number < quarterPoints; number++) {
+++
+++ aVal = _mm_loadu_ps(aPtr);
+++ x2 = _mm_mul_ps(aVal, aVal);
+++ a = _mm_mul_ps(
+++ aVal,
+++ _mm_add_ps(
+++ const1,
+++ _mm_mul_ps(x2,
+++ _mm_add_ps(const2, _mm_mul_ps(x2, _mm_add_ps(const3, x2))))));
+++ b = _mm_add_ps(
+++ const1,
+++ _mm_mul_ps(
+++ x2,
+++ _mm_add_ps(const4,
+++ _mm_mul_ps(x2, _mm_add_ps(const5, _mm_mul_ps(x2, const6))))));
+++
+++ cVal = _mm_div_ps(a, b);
+++
+++ _mm_storeu_ps(cPtr, cVal); // Store the results back into the C container
+++
+++ aPtr += 4;
+++ cPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ if (*aPtr > 4.97)
+++ *cPtr++ = 1;
+++ else if (*aPtr <= -4.97)
+++ *cPtr++ = -1;
+++ else {
+++ float x2 = (*aPtr) * (*aPtr);
+++ float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
+++ float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
+++ *cPtr++ = a / b;
+++ aPtr++;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -348,52 +379,65 @@ volk_32f_tanh_32f_u_sse(float* cVector, const float* aVector,
++ #include <immintrin.h>
++
++ static inline void
++-volk_32f_tanh_32f_u_avx(float* cVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tanh_32f_u_avx(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++-
++- __m256 aVal, cVal, x2, a, b;
++- __m256 const1, const2, const3, const4, const5, const6;
++- const1 = _mm256_set1_ps(135135.0f);
++- const2 = _mm256_set1_ps(17325.0f);
++- const3 = _mm256_set1_ps(378.0f);
++- const4 = _mm256_set1_ps(62370.0f);
++- const5 = _mm256_set1_ps(3150.0f);
++- const6 = _mm256_set1_ps(28.0f);
++- for(;number < eighthPoints; number++){
++-
++- aVal = _mm256_loadu_ps(aPtr);
++- x2 = _mm256_mul_ps(aVal, aVal);
++- a = _mm256_mul_ps(aVal, _mm256_add_ps(const1, _mm256_mul_ps(x2, _mm256_add_ps(const2, _mm256_mul_ps(x2, _mm256_add_ps(const3, x2))))));
++- b = _mm256_add_ps(const1, _mm256_mul_ps(x2, _mm256_add_ps(const4, _mm256_mul_ps(x2, _mm256_add_ps(const5, _mm256_mul_ps(x2, const6))))));
++-
++- cVal = _mm256_div_ps(a, b);
++-
++- _mm256_storeu_ps(cPtr, cVal); // Store the results back into the C container
++-
++- aPtr += 8;
++- cPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++) {
++- if(*aPtr > 4.97)
++- *cPtr++ = 1;
++- else if(*aPtr <= -4.97)
++- *cPtr++ = -1;
++- else {
++- float x2 = (*aPtr) * (*aPtr);
++- float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
++- float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
++- *cPtr++ = a / b;
++- aPtr++;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++
+++ __m256 aVal, cVal, x2, a, b;
+++ __m256 const1, const2, const3, const4, const5, const6;
+++ const1 = _mm256_set1_ps(135135.0f);
+++ const2 = _mm256_set1_ps(17325.0f);
+++ const3 = _mm256_set1_ps(378.0f);
+++ const4 = _mm256_set1_ps(62370.0f);
+++ const5 = _mm256_set1_ps(3150.0f);
+++ const6 = _mm256_set1_ps(28.0f);
+++ for (; number < eighthPoints; number++) {
+++
+++ aVal = _mm256_loadu_ps(aPtr);
+++ x2 = _mm256_mul_ps(aVal, aVal);
+++ a = _mm256_mul_ps(
+++ aVal,
+++ _mm256_add_ps(
+++ const1,
+++ _mm256_mul_ps(
+++ x2,
+++ _mm256_add_ps(const2,
+++ _mm256_mul_ps(x2, _mm256_add_ps(const3, x2))))));
+++ b = _mm256_add_ps(
+++ const1,
+++ _mm256_mul_ps(
+++ x2,
+++ _mm256_add_ps(
+++ const4,
+++ _mm256_mul_ps(x2,
+++ _mm256_add_ps(const5, _mm256_mul_ps(x2, const6))))));
+++
+++ cVal = _mm256_div_ps(a, b);
+++
+++ _mm256_storeu_ps(cPtr, cVal); // Store the results back into the C container
+++
+++ aPtr += 8;
+++ cPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ if (*aPtr > 4.97)
+++ *cPtr++ = 1;
+++ else if (*aPtr <= -4.97)
+++ *cPtr++ = -1;
+++ else {
+++ float x2 = (*aPtr) * (*aPtr);
+++ float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
+++ float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
+++ *cPtr++ = a / b;
+++ aPtr++;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -401,52 +445,55 @@ volk_32f_tanh_32f_u_avx(float* cVector, const float* aVector,
++ #include <immintrin.h>
++
++ static inline void
++-volk_32f_tanh_32f_u_avx_fma(float* cVector, const float* aVector,
++- unsigned int num_points)
+++volk_32f_tanh_32f_u_avx_fma(float* cVector, const float* aVector, unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++-
++- __m256 aVal, cVal, x2, a, b;
++- __m256 const1, const2, const3, const4, const5, const6;
++- const1 = _mm256_set1_ps(135135.0f);
++- const2 = _mm256_set1_ps(17325.0f);
++- const3 = _mm256_set1_ps(378.0f);
++- const4 = _mm256_set1_ps(62370.0f);
++- const5 = _mm256_set1_ps(3150.0f);
++- const6 = _mm256_set1_ps(28.0f);
++- for(;number < eighthPoints; number++){
++-
++- aVal = _mm256_loadu_ps(aPtr);
++- x2 = _mm256_mul_ps(aVal, aVal);
++- a = _mm256_mul_ps(aVal, _mm256_fmadd_ps(x2, _mm256_fmadd_ps(x2, _mm256_add_ps(const3, x2), const2),const1));
++- b = _mm256_fmadd_ps(x2, _mm256_fmadd_ps(x2, _mm256_fmadd_ps(x2, const6, const5), const4), const1);
++-
++- cVal = _mm256_div_ps(a, b);
++-
++- _mm256_storeu_ps(cPtr, cVal); // Store the results back into the C container
++-
++- aPtr += 8;
++- cPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++) {
++- if(*aPtr > 4.97)
++- *cPtr++ = 1;
++- else if(*aPtr <= -4.97)
++- *cPtr++ = -1;
++- else {
++- float x2 = (*aPtr) * (*aPtr);
++- float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
++- float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
++- *cPtr++ = a / b;
++- aPtr++;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++
+++ __m256 aVal, cVal, x2, a, b;
+++ __m256 const1, const2, const3, const4, const5, const6;
+++ const1 = _mm256_set1_ps(135135.0f);
+++ const2 = _mm256_set1_ps(17325.0f);
+++ const3 = _mm256_set1_ps(378.0f);
+++ const4 = _mm256_set1_ps(62370.0f);
+++ const5 = _mm256_set1_ps(3150.0f);
+++ const6 = _mm256_set1_ps(28.0f);
+++ for (; number < eighthPoints; number++) {
+++
+++ aVal = _mm256_loadu_ps(aPtr);
+++ x2 = _mm256_mul_ps(aVal, aVal);
+++ a = _mm256_mul_ps(
+++ aVal,
+++ _mm256_fmadd_ps(
+++ x2, _mm256_fmadd_ps(x2, _mm256_add_ps(const3, x2), const2), const1));
+++ b = _mm256_fmadd_ps(
+++ x2, _mm256_fmadd_ps(x2, _mm256_fmadd_ps(x2, const6, const5), const4), const1);
+++
+++ cVal = _mm256_div_ps(a, b);
+++
+++ _mm256_storeu_ps(cPtr, cVal); // Store the results back into the C container
+++
+++ aPtr += 8;
+++ cPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ if (*aPtr > 4.97)
+++ *cPtr++ = 1;
+++ else if (*aPtr <= -4.97)
+++ *cPtr++ = -1;
+++ else {
+++ float x2 = (*aPtr) * (*aPtr);
+++ float a = (*aPtr) * (135135.0f + x2 * (17325.0f + x2 * (378.0f + x2)));
+++ float b = 135135.0f + x2 * (62370.0f + x2 * (3150.0f + x2 * 28.0f));
+++ *cPtr++ = a / b;
+++ aPtr++;
+++ }
++ }
++- }
++ }
++ #endif /* LV_HAVE_AVX && LV_HAVE_FMA */
++
++diff --git a/kernels/volk/volk_32f_x2_add_32f.h b/kernels/volk/volk_32f_x2_add_32f.h
++index ce18092..e4b7e93 100644
++--- a/kernels/volk/volk_32f_x2_add_32f.h
+++++ b/kernels/volk/volk_32f_x2_add_32f.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_x2_add_32f(float* cVector, const float* aVector, const float* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_x2_add_32f(float* cVector, const float* aVector, const float* bVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: First vector of input points.
++@@ -44,7 +44,8 @@
++ *
++ * \b Example
++ *
++- * The follow example adds the increasing and decreasing vectors such that the result of every summation pair is 10
+++ * The follow example adds the increasing and decreasing vectors such that the result of
+++ * every summation pair is 10
++ *
++ * \code
++ * int N = 10;
++@@ -79,37 +80,38 @@
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_add_32f_u_avx512f(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_add_32f_u_avx512f(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m512 aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
+++ __m512 aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
++
++- aVal = _mm512_loadu_ps(aPtr);
++- bVal = _mm512_loadu_ps(bPtr);
+++ aVal = _mm512_loadu_ps(aPtr);
+++ bVal = _mm512_loadu_ps(bPtr);
++
++- cVal = _mm512_add_ps(aVal, bVal);
+++ cVal = _mm512_add_ps(aVal, bVal);
++
++- _mm512_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm512_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
+++ number = sixteenthPoints * 16;
++
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX512F */
++@@ -118,35 +120,36 @@ volk_32f_x2_add_32f_u_avx512f(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_add_32f_u_avx(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_add_32f_u_avx(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
++- __m256 aVal, bVal, cVal;
++- for(;number < eighthPoints; number++){
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ __m256 aVal, bVal, cVal;
+++ for (; number < eighthPoints; number++) {
++
++- aVal = _mm256_loadu_ps(aPtr);
++- bVal = _mm256_loadu_ps(bPtr);
+++ aVal = _mm256_loadu_ps(aPtr);
+++ bVal = _mm256_loadu_ps(bPtr);
++
++- cVal = _mm256_add_ps(aVal, bVal);
+++ cVal = _mm256_add_ps(aVal, bVal);
++
++- _mm256_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
+++ number = eighthPoints * 8;
++
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -154,54 +157,56 @@ volk_32f_x2_add_32f_u_avx(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_x2_add_32f_u_sse(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_add_32f_u_sse(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m128 aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
+++ __m128 aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm_loadu_ps(aPtr);
++- bVal = _mm_loadu_ps(bPtr);
+++ aVal = _mm_loadu_ps(aPtr);
+++ bVal = _mm_loadu_ps(bPtr);
++
++- cVal = _mm_add_ps(aVal, bVal);
+++ cVal = _mm_add_ps(aVal, bVal);
++
++- _mm_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_x2_add_32f_generic(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_add_32f_generic(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -216,37 +221,38 @@ volk_32f_x2_add_32f_generic(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_add_32f_a_avx512f(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_add_32f_a_avx512f(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m512 aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
+++ __m512 aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
++
++- aVal = _mm512_load_ps(aPtr);
++- bVal = _mm512_load_ps(bPtr);
+++ aVal = _mm512_load_ps(aPtr);
+++ bVal = _mm512_load_ps(bPtr);
++
++- cVal = _mm512_add_ps(aVal, bVal);
+++ cVal = _mm512_add_ps(aVal, bVal);
++
++- _mm512_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm512_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
+++ number = sixteenthPoints * 16;
++
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX512F */
++@@ -255,70 +261,73 @@ volk_32f_x2_add_32f_a_avx512f(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_add_32f_a_avx(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_add_32f_a_avx(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m256 aVal, bVal, cVal;
++- for(;number < eighthPoints; number++){
+++ __m256 aVal, bVal, cVal;
+++ for (; number < eighthPoints; number++) {
++
++- aVal = _mm256_load_ps(aPtr);
++- bVal = _mm256_load_ps(bPtr);
+++ aVal = _mm256_load_ps(aPtr);
+++ bVal = _mm256_load_ps(bPtr);
++
++- cVal = _mm256_add_ps(aVal, bVal);
+++ cVal = _mm256_add_ps(aVal, bVal);
++
++- _mm256_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_x2_add_32f_a_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_add_32f_a_sse(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m128 aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
++- aVal = _mm_load_ps(aPtr);
++- bVal = _mm_load_ps(bPtr);
+++ __m128 aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
+++ bVal = _mm_load_ps(bPtr);
++
++- cVal = _mm_add_ps(aVal, bVal);
+++ cVal = _mm_add_ps(aVal, bVal);
++
++- _mm_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -326,78 +335,89 @@ volk_32f_x2_add_32f_a_sse(float* cVector, const float* aVector, const float* bVe
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32f_x2_add_32f_u_neon(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_add_32f_u_neon(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
++- float32x4_t aVal, bVal, cVal;
++- for(number=0; number < quarterPoints; number++){
++- // Load in to NEON registers
++- aVal = vld1q_f32(aPtr);
++- bVal = vld1q_f32(bPtr);
++- __VOLK_PREFETCH(aPtr+4);
++- __VOLK_PREFETCH(bPtr+4);
++-
++- // vector add
++- cVal = vaddq_f32(aVal, bVal);
++- // Store the results back into the C container
++- vst1q_f32(cPtr,cVal);
++-
++- aPtr += 4; // q uses quadwords, 4 floats per vadd
++- bPtr += 4;
++- cPtr += 4;
++- }
++-
++- number = quarterPoints * 4; // should be = num_points
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ float32x4_t aVal, bVal, cVal;
+++ for (number = 0; number < quarterPoints; number++) {
+++ // Load in to NEON registers
+++ aVal = vld1q_f32(aPtr);
+++ bVal = vld1q_f32(bPtr);
+++ __VOLK_PREFETCH(aPtr + 4);
+++ __VOLK_PREFETCH(bPtr + 4);
+++
+++ // vector add
+++ cVal = vaddq_f32(aVal, bVal);
+++ // Store the results back into the C container
+++ vst1q_f32(cPtr, cVal);
+++
+++ aPtr += 4; // q uses quadwords, 4 floats per vadd
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4; // should be = num_points
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_NEON */
++
++ #ifdef LV_HAVE_NEONV7
++-extern void volk_32f_x2_add_32f_a_neonasm(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
+++extern void volk_32f_x2_add_32f_a_neonasm(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points);
++ #endif /* LV_HAVE_NEONV7 */
++
++ #ifdef LV_HAVE_NEONV7
++-extern void volk_32f_x2_add_32f_a_neonpipeline(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
+++extern void volk_32f_x2_add_32f_a_neonpipeline(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points);
++ #endif /* LV_HAVE_NEONV7 */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_x2_add_32f_a_generic(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_add_32f_a_generic(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++ #ifdef LV_HAVE_ORC
++
++-extern void
++-volk_32f_x2_add_32f_a_orc_impl(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points);
+++extern void volk_32f_x2_add_32f_a_orc_impl(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points);
++
++-static inline void
++-volk_32f_x2_add_32f_u_orc(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points){
++- volk_32f_x2_add_32f_a_orc_impl(cVector, aVector, bVector, num_points);
+++static inline void volk_32f_x2_add_32f_u_orc(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
+++{
+++ volk_32f_x2_add_32f_a_orc_impl(cVector, aVector, bVector, num_points);
++ }
++
++ #endif /* LV_HAVE_ORC */
++diff --git a/kernels/volk/volk_32f_x2_divide_32f.h b/kernels/volk/volk_32f_x2_divide_32f.h
++index 130767f..8b80365 100644
++--- a/kernels/volk/volk_32f_x2_divide_32f.h
+++++ b/kernels/volk/volk_32f_x2_divide_32f.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_x2_divide_32f(float* cVector, const float* aVector, const float* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_x2_divide_32f(float* cVector, const float* aVector, const float* bVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: First vector of input points.
++@@ -77,35 +77,36 @@
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_divide_32f_a_avx512f(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_divide_32f_a_avx512f(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m512 aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
++- aVal = _mm512_load_ps(aPtr);
++- bVal = _mm512_load_ps(bPtr);
+++ __m512 aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
+++ aVal = _mm512_load_ps(aPtr);
+++ bVal = _mm512_load_ps(bPtr);
++
++- cVal = _mm512_div_ps(aVal, bVal);
+++ cVal = _mm512_div_ps(aVal, bVal);
++
++- _mm512_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm512_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) / (*bPtr++);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) / (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++@@ -113,35 +114,36 @@ volk_32f_x2_divide_32f_a_avx512f(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_divide_32f_a_avx(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_divide_32f_a_avx(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m256 aVal, bVal, cVal;
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- bVal = _mm256_load_ps(bPtr);
+++ __m256 aVal, bVal, cVal;
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ bVal = _mm256_load_ps(bPtr);
++
++- cVal = _mm256_div_ps(aVal, bVal);
+++ cVal = _mm256_div_ps(aVal, bVal);
++
++- _mm256_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) / (*bPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) / (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -149,35 +151,36 @@ volk_32f_x2_divide_32f_a_avx(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_x2_divide_32f_a_sse(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_divide_32f_a_sse(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m128 aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
++- aVal = _mm_load_ps(aPtr);
++- bVal = _mm_load_ps(bPtr);
+++ __m128 aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
+++ bVal = _mm_load_ps(bPtr);
++
++- cVal = _mm_div_ps(aVal, bVal);
+++ cVal = _mm_div_ps(aVal, bVal);
++
++- _mm_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) / (*bPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) / (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -185,54 +188,55 @@ volk_32f_x2_divide_32f_a_sse(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32f_x2_divide_32f_neon(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_divide_32f_neon(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr = bVector;
++-
++- float32x4x4_t aVal, bVal, bInv, cVal;
++-
++- const unsigned int eighthPoints = num_points / 16;
++- unsigned int number = 0;
++- for(; number < eighthPoints; number++){
++- aVal = vld4q_f32(aPtr);
++- aPtr += 16;
++- bVal = vld4q_f32(bPtr);
++- bPtr += 16;
++-
++- __VOLK_PREFETCH(aPtr+16);
++- __VOLK_PREFETCH(bPtr+16);
++-
++- bInv.val[0] = vrecpeq_f32(bVal.val[0]);
++- bInv.val[0] = vmulq_f32(bInv.val[0], vrecpsq_f32(bInv.val[0], bVal.val[0]));
++- bInv.val[0] = vmulq_f32(bInv.val[0], vrecpsq_f32(bInv.val[0], bVal.val[0]));
++- cVal.val[0] = vmulq_f32(aVal.val[0], bInv.val[0]);
++-
++- bInv.val[1] = vrecpeq_f32(bVal.val[1]);
++- bInv.val[1] = vmulq_f32(bInv.val[1], vrecpsq_f32(bInv.val[1], bVal.val[1]));
++- bInv.val[1] = vmulq_f32(bInv.val[1], vrecpsq_f32(bInv.val[1], bVal.val[1]));
++- cVal.val[1] = vmulq_f32(aVal.val[1], bInv.val[1]);
++-
++- bInv.val[2] = vrecpeq_f32(bVal.val[2]);
++- bInv.val[2] = vmulq_f32(bInv.val[2], vrecpsq_f32(bInv.val[2], bVal.val[2]));
++- bInv.val[2] = vmulq_f32(bInv.val[2], vrecpsq_f32(bInv.val[2], bVal.val[2]));
++- cVal.val[2] = vmulq_f32(aVal.val[2], bInv.val[2]);
++-
++- bInv.val[3] = vrecpeq_f32(bVal.val[3]);
++- bInv.val[3] = vmulq_f32(bInv.val[3], vrecpsq_f32(bInv.val[3], bVal.val[3]));
++- bInv.val[3] = vmulq_f32(bInv.val[3], vrecpsq_f32(bInv.val[3], bVal.val[3]));
++- cVal.val[3] = vmulq_f32(aVal.val[3], bInv.val[3]);
++-
++- vst4q_f32(cPtr, cVal);
++- cPtr += 16;
++- }
++-
++- for(number = eighthPoints * 16; number < num_points; number++){
++- *cPtr++ = (*aPtr++) / (*bPtr++);
++- }
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++
+++ float32x4x4_t aVal, bVal, bInv, cVal;
+++
+++ const unsigned int eighthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ for (; number < eighthPoints; number++) {
+++ aVal = vld4q_f32(aPtr);
+++ aPtr += 16;
+++ bVal = vld4q_f32(bPtr);
+++ bPtr += 16;
+++
+++ __VOLK_PREFETCH(aPtr + 16);
+++ __VOLK_PREFETCH(bPtr + 16);
+++
+++ bInv.val[0] = vrecpeq_f32(bVal.val[0]);
+++ bInv.val[0] = vmulq_f32(bInv.val[0], vrecpsq_f32(bInv.val[0], bVal.val[0]));
+++ bInv.val[0] = vmulq_f32(bInv.val[0], vrecpsq_f32(bInv.val[0], bVal.val[0]));
+++ cVal.val[0] = vmulq_f32(aVal.val[0], bInv.val[0]);
+++
+++ bInv.val[1] = vrecpeq_f32(bVal.val[1]);
+++ bInv.val[1] = vmulq_f32(bInv.val[1], vrecpsq_f32(bInv.val[1], bVal.val[1]));
+++ bInv.val[1] = vmulq_f32(bInv.val[1], vrecpsq_f32(bInv.val[1], bVal.val[1]));
+++ cVal.val[1] = vmulq_f32(aVal.val[1], bInv.val[1]);
+++
+++ bInv.val[2] = vrecpeq_f32(bVal.val[2]);
+++ bInv.val[2] = vmulq_f32(bInv.val[2], vrecpsq_f32(bInv.val[2], bVal.val[2]));
+++ bInv.val[2] = vmulq_f32(bInv.val[2], vrecpsq_f32(bInv.val[2], bVal.val[2]));
+++ cVal.val[2] = vmulq_f32(aVal.val[2], bInv.val[2]);
+++
+++ bInv.val[3] = vrecpeq_f32(bVal.val[3]);
+++ bInv.val[3] = vmulq_f32(bInv.val[3], vrecpsq_f32(bInv.val[3], bVal.val[3]));
+++ bInv.val[3] = vmulq_f32(bInv.val[3], vrecpsq_f32(bInv.val[3], bVal.val[3]));
+++ cVal.val[3] = vmulq_f32(aVal.val[3], bInv.val[3]);
+++
+++ vst4q_f32(cPtr, cVal);
+++ cPtr += 16;
+++ }
+++
+++ for (number = eighthPoints * 16; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) / (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_NEON */
++@@ -240,38 +244,40 @@ volk_32f_x2_divide_32f_neon(float* cVector, const float* aVector,
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_x2_divide_32f_generic(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_divide_32f_generic(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) / (*bPtr++);
++- }
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) / (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++ #ifdef LV_HAVE_ORC
++
++-extern void
++-volk_32f_x2_divide_32f_a_orc_impl(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points);
+++extern void volk_32f_x2_divide_32f_a_orc_impl(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points);
++
++-static inline void
++-volk_32f_x2_divide_32f_u_orc(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_divide_32f_u_orc(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- volk_32f_x2_divide_32f_a_orc_impl(cVector, aVector, bVector, num_points);
+++ volk_32f_x2_divide_32f_a_orc_impl(cVector, aVector, bVector, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++
++-
++ #endif /* INCLUDED_volk_32f_x2_divide_32f_a_H */
++
++
++@@ -284,35 +290,36 @@ volk_32f_x2_divide_32f_u_orc(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_divide_32f_u_avx512f(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_divide_32f_u_avx512f(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m512 aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
++- aVal = _mm512_loadu_ps(aPtr);
++- bVal = _mm512_loadu_ps(bPtr);
+++ __m512 aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
+++ aVal = _mm512_loadu_ps(aPtr);
+++ bVal = _mm512_loadu_ps(bPtr);
++
++- cVal = _mm512_div_ps(aVal, bVal);
+++ cVal = _mm512_div_ps(aVal, bVal);
++
++- _mm512_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm512_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) / (*bPtr++);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) / (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++@@ -320,35 +327,36 @@ volk_32f_x2_divide_32f_u_avx512f(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_divide_32f_u_avx(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_divide_32f_u_avx(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m256 aVal, bVal, cVal;
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- bVal = _mm256_loadu_ps(bPtr);
+++ __m256 aVal, bVal, cVal;
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ bVal = _mm256_loadu_ps(bPtr);
++
++- cVal = _mm256_div_ps(aVal, bVal);
+++ cVal = _mm256_div_ps(aVal, bVal);
++
++- _mm256_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) / (*bPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) / (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++diff --git a/kernels/volk/volk_32f_x2_dot_prod_16i.h b/kernels/volk/volk_32f_x2_dot_prod_16i.h
++index c1b5a82..4da7db6 100644
++--- a/kernels/volk/volk_32f_x2_dot_prod_16i.h
+++++ b/kernels/volk/volk_32f_x2_dot_prod_16i.h
++@@ -33,8 +33,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_x2_dot_prod_16i(int16_t* result, const float* input, const float* taps, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_x2_dot_prod_16i(int16_t* result, const float* input, const float* taps,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li input: vector of floats.
++@@ -58,25 +58,29 @@
++ #ifndef INCLUDED_volk_32f_x2_dot_prod_16i_H
++ #define INCLUDED_volk_32f_x2_dot_prod_16i_H
++
++-#include <volk/volk_common.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++
++ #ifdef LV_HAVE_GENERIC
++
++
++-static inline void volk_32f_x2_dot_prod_16i_generic(int16_t* result, const float* input, const float* taps, unsigned int num_points) {
+++static inline void volk_32f_x2_dot_prod_16i_generic(int16_t* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
++
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr= taps;
++- unsigned int number = 0;
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
+++ for (number = 0; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
++- *result = (int16_t)dotProduct;
+++ *result = (int16_t)dotProduct;
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -84,68 +88,73 @@ static inline void volk_32f_x2_dot_prod_16i_generic(int16_t* result, const float
++
++ #ifdef LV_HAVE_SSE
++
++-static inline void volk_32f_x2_dot_prod_16i_a_sse(int16_t* result, const float* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
++-
++- __m128 a0Val, a1Val, a2Val, a3Val;
++- __m128 b0Val, b1Val, b2Val, b3Val;
++- __m128 c0Val, c1Val, c2Val, c3Val;
++-
++- __m128 dotProdVal0 = _mm_setzero_ps();
++- __m128 dotProdVal1 = _mm_setzero_ps();
++- __m128 dotProdVal2 = _mm_setzero_ps();
++- __m128 dotProdVal3 = _mm_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- a0Val = _mm_load_ps(aPtr);
++- a1Val = _mm_load_ps(aPtr+4);
++- a2Val = _mm_load_ps(aPtr+8);
++- a3Val = _mm_load_ps(aPtr+12);
++- b0Val = _mm_load_ps(bPtr);
++- b1Val = _mm_load_ps(bPtr+4);
++- b2Val = _mm_load_ps(bPtr+8);
++- b3Val = _mm_load_ps(bPtr+12);
++-
++- c0Val = _mm_mul_ps(a0Val, b0Val);
++- c1Val = _mm_mul_ps(a1Val, b1Val);
++- c2Val = _mm_mul_ps(a2Val, b2Val);
++- c3Val = _mm_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
++-
++- aPtr += 16;
++- bPtr += 16;
++- }
++-
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
++-
++- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
++-
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = (short)dotProduct;
+++static inline void volk_32f_x2_dot_prod_16i_a_sse(int16_t* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m128 a0Val, a1Val, a2Val, a3Val;
+++ __m128 b0Val, b1Val, b2Val, b3Val;
+++ __m128 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m128 dotProdVal0 = _mm_setzero_ps();
+++ __m128 dotProdVal1 = _mm_setzero_ps();
+++ __m128 dotProdVal2 = _mm_setzero_ps();
+++ __m128 dotProdVal3 = _mm_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ a0Val = _mm_load_ps(aPtr);
+++ a1Val = _mm_load_ps(aPtr + 4);
+++ a2Val = _mm_load_ps(aPtr + 8);
+++ a3Val = _mm_load_ps(aPtr + 12);
+++ b0Val = _mm_load_ps(bPtr);
+++ b1Val = _mm_load_ps(bPtr + 4);
+++ b2Val = _mm_load_ps(bPtr + 8);
+++ b3Val = _mm_load_ps(bPtr + 12);
+++
+++ c0Val = _mm_mul_ps(a0Val, b0Val);
+++ c1Val = _mm_mul_ps(a1Val, b1Val);
+++ c2Val = _mm_mul_ps(a2Val, b2Val);
+++ c3Val = _mm_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
+++
+++ aPtr += 16;
+++ bPtr += 16;
+++ }
+++
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
+++
+++ _mm_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = (short)dotProduct;
++ }
++
++ #endif /*LV_HAVE_SSE*/
++@@ -153,66 +162,71 @@ static inline void volk_32f_x2_dot_prod_16i_a_sse(int16_t* result, const float*
++
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++
++-static inline void volk_32f_x2_dot_prod_16i_a_avx2_fma(int16_t* result, const float* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int thirtysecondPoints = num_points / 32;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
++-
++- __m256 a0Val, a1Val, a2Val, a3Val;
++- __m256 b0Val, b1Val, b2Val, b3Val;
++-
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
++- __m256 dotProdVal2 = _mm256_setzero_ps();
++- __m256 dotProdVal3 = _mm256_setzero_ps();
++-
++- for(;number < thirtysecondPoints; number++){
++-
++- a0Val = _mm256_load_ps(aPtr);
++- a1Val = _mm256_load_ps(aPtr+8);
++- a2Val = _mm256_load_ps(aPtr+16);
++- a3Val = _mm256_load_ps(aPtr+24);
++- b0Val = _mm256_load_ps(bPtr);
++- b1Val = _mm256_load_ps(bPtr+8);
++- b2Val = _mm256_load_ps(bPtr+16);
++- b3Val = _mm256_load_ps(bPtr+24);
++-
++- dotProdVal0 = _mm256_fmadd_ps(a0Val, b0Val, dotProdVal0);
++- dotProdVal1 = _mm256_fmadd_ps(a1Val, b1Val, dotProdVal1);
++- dotProdVal2 = _mm256_fmadd_ps(a2Val, b2Val, dotProdVal2);
++- dotProdVal3 = _mm256_fmadd_ps(a3Val, b3Val, dotProdVal3);
++-
++- aPtr += 32;
++- bPtr += 32;
++- }
++-
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++-
++- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
++- dotProduct += dotProductVector[4];
++- dotProduct += dotProductVector[5];
++- dotProduct += dotProductVector[6];
++- dotProduct += dotProductVector[7];
++-
++- number = thirtysecondPoints*32;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = (short)dotProduct;
+++static inline void volk_32f_x2_dot_prod_16i_a_avx2_fma(int16_t* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int thirtysecondPoints = num_points / 32;
+++
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m256 a0Val, a1Val, a2Val, a3Val;
+++ __m256 b0Val, b1Val, b2Val, b3Val;
+++
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 dotProdVal2 = _mm256_setzero_ps();
+++ __m256 dotProdVal3 = _mm256_setzero_ps();
+++
+++ for (; number < thirtysecondPoints; number++) {
+++
+++ a0Val = _mm256_load_ps(aPtr);
+++ a1Val = _mm256_load_ps(aPtr + 8);
+++ a2Val = _mm256_load_ps(aPtr + 16);
+++ a3Val = _mm256_load_ps(aPtr + 24);
+++ b0Val = _mm256_load_ps(bPtr);
+++ b1Val = _mm256_load_ps(bPtr + 8);
+++ b2Val = _mm256_load_ps(bPtr + 16);
+++ b3Val = _mm256_load_ps(bPtr + 24);
+++
+++ dotProdVal0 = _mm256_fmadd_ps(a0Val, b0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_fmadd_ps(a1Val, b1Val, dotProdVal1);
+++ dotProdVal2 = _mm256_fmadd_ps(a2Val, b2Val, dotProdVal2);
+++ dotProdVal3 = _mm256_fmadd_ps(a3Val, b3Val, dotProdVal3);
+++
+++ aPtr += 32;
+++ bPtr += 32;
+++ }
+++
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
+++ dotProduct += dotProductVector[4];
+++ dotProduct += dotProductVector[5];
+++ dotProduct += dotProductVector[6];
+++ dotProduct += dotProductVector[7];
+++
+++ number = thirtysecondPoints * 32;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = (short)dotProduct;
++ }
++
++ #endif /*LV_HAVE_AVX2 && LV_HAVE_FMA*/
++@@ -220,146 +234,156 @@ static inline void volk_32f_x2_dot_prod_16i_a_avx2_fma(int16_t* result, const f
++
++ #ifdef LV_HAVE_AVX
++
++-static inline void volk_32f_x2_dot_prod_16i_a_avx(int16_t* result, const float* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int thirtysecondPoints = num_points / 32;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
++-
++- __m256 a0Val, a1Val, a2Val, a3Val;
++- __m256 b0Val, b1Val, b2Val, b3Val;
++- __m256 c0Val, c1Val, c2Val, c3Val;
++-
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
++- __m256 dotProdVal2 = _mm256_setzero_ps();
++- __m256 dotProdVal3 = _mm256_setzero_ps();
++-
++- for(;number < thirtysecondPoints; number++){
++-
++- a0Val = _mm256_load_ps(aPtr);
++- a1Val = _mm256_load_ps(aPtr+8);
++- a2Val = _mm256_load_ps(aPtr+16);
++- a3Val = _mm256_load_ps(aPtr+24);
++- b0Val = _mm256_load_ps(bPtr);
++- b1Val = _mm256_load_ps(bPtr+8);
++- b2Val = _mm256_load_ps(bPtr+16);
++- b3Val = _mm256_load_ps(bPtr+24);
++-
++- c0Val = _mm256_mul_ps(a0Val, b0Val);
++- c1Val = _mm256_mul_ps(a1Val, b1Val);
++- c2Val = _mm256_mul_ps(a2Val, b2Val);
++- c3Val = _mm256_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm256_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm256_add_ps(c3Val, dotProdVal3);
++-
++- aPtr += 32;
++- bPtr += 32;
++- }
++-
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++-
++- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
++- dotProduct += dotProductVector[4];
++- dotProduct += dotProductVector[5];
++- dotProduct += dotProductVector[6];
++- dotProduct += dotProductVector[7];
++-
++- number = thirtysecondPoints*32;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = (short)dotProduct;
+++static inline void volk_32f_x2_dot_prod_16i_a_avx(int16_t* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int thirtysecondPoints = num_points / 32;
+++
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m256 a0Val, a1Val, a2Val, a3Val;
+++ __m256 b0Val, b1Val, b2Val, b3Val;
+++ __m256 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 dotProdVal2 = _mm256_setzero_ps();
+++ __m256 dotProdVal3 = _mm256_setzero_ps();
+++
+++ for (; number < thirtysecondPoints; number++) {
+++
+++ a0Val = _mm256_load_ps(aPtr);
+++ a1Val = _mm256_load_ps(aPtr + 8);
+++ a2Val = _mm256_load_ps(aPtr + 16);
+++ a3Val = _mm256_load_ps(aPtr + 24);
+++ b0Val = _mm256_load_ps(bPtr);
+++ b1Val = _mm256_load_ps(bPtr + 8);
+++ b2Val = _mm256_load_ps(bPtr + 16);
+++ b3Val = _mm256_load_ps(bPtr + 24);
+++
+++ c0Val = _mm256_mul_ps(a0Val, b0Val);
+++ c1Val = _mm256_mul_ps(a1Val, b1Val);
+++ c2Val = _mm256_mul_ps(a2Val, b2Val);
+++ c3Val = _mm256_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm256_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm256_add_ps(c3Val, dotProdVal3);
+++
+++ aPtr += 32;
+++ bPtr += 32;
+++ }
+++
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
+++ dotProduct += dotProductVector[4];
+++ dotProduct += dotProductVector[5];
+++ dotProduct += dotProductVector[6];
+++ dotProduct += dotProductVector[7];
+++
+++ number = thirtysecondPoints * 32;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = (short)dotProduct;
++ }
++
++ #endif /*LV_HAVE_AVX*/
++
++ #ifdef LV_HAVE_AVX512F
++
++-static inline void volk_32f_x2_dot_prod_16i_a_avx512f(int16_t* result, const float* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixtyfourthPoints = num_points / 64;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
++-
++- __m512 a0Val, a1Val, a2Val, a3Val;
++- __m512 b0Val, b1Val, b2Val, b3Val;
++-
++- __m512 dotProdVal0 = _mm512_setzero_ps();
++- __m512 dotProdVal1 = _mm512_setzero_ps();
++- __m512 dotProdVal2 = _mm512_setzero_ps();
++- __m512 dotProdVal3 = _mm512_setzero_ps();
++-
++- for(;number < sixtyfourthPoints; number++){
++-
++- a0Val = _mm512_load_ps(aPtr);
++- a1Val = _mm512_load_ps(aPtr+16);
++- a2Val = _mm512_load_ps(aPtr+32);
++- a3Val = _mm512_load_ps(aPtr+48);
++- b0Val = _mm512_load_ps(bPtr);
++- b1Val = _mm512_load_ps(bPtr+16);
++- b2Val = _mm512_load_ps(bPtr+32);
++- b3Val = _mm512_load_ps(bPtr+48);
++-
++- dotProdVal0 = _mm512_fmadd_ps(a0Val, b0Val, dotProdVal0);
++- dotProdVal1 = _mm512_fmadd_ps(a1Val, b1Val, dotProdVal1);
++- dotProdVal2 = _mm512_fmadd_ps(a2Val, b2Val, dotProdVal2);
++- dotProdVal3 = _mm512_fmadd_ps(a3Val, b3Val, dotProdVal3);
++-
++- aPtr += 64;
++- bPtr += 64;
++- }
++-
++- dotProdVal0 = _mm512_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm512_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm512_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(64) float dotProductVector[16];
++-
++- _mm512_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
++- dotProduct += dotProductVector[4];
++- dotProduct += dotProductVector[5];
++- dotProduct += dotProductVector[6];
++- dotProduct += dotProductVector[7];
++- dotProduct += dotProductVector[8];
++- dotProduct += dotProductVector[9];
++- dotProduct += dotProductVector[10];
++- dotProduct += dotProductVector[11];
++- dotProduct += dotProductVector[12];
++- dotProduct += dotProductVector[13];
++- dotProduct += dotProductVector[14];
++- dotProduct += dotProductVector[15];
++-
++- number = sixtyfourthPoints*64;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = (short)dotProduct;
+++static inline void volk_32f_x2_dot_prod_16i_a_avx512f(int16_t* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixtyfourthPoints = num_points / 64;
+++
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m512 a0Val, a1Val, a2Val, a3Val;
+++ __m512 b0Val, b1Val, b2Val, b3Val;
+++
+++ __m512 dotProdVal0 = _mm512_setzero_ps();
+++ __m512 dotProdVal1 = _mm512_setzero_ps();
+++ __m512 dotProdVal2 = _mm512_setzero_ps();
+++ __m512 dotProdVal3 = _mm512_setzero_ps();
+++
+++ for (; number < sixtyfourthPoints; number++) {
+++
+++ a0Val = _mm512_load_ps(aPtr);
+++ a1Val = _mm512_load_ps(aPtr + 16);
+++ a2Val = _mm512_load_ps(aPtr + 32);
+++ a3Val = _mm512_load_ps(aPtr + 48);
+++ b0Val = _mm512_load_ps(bPtr);
+++ b1Val = _mm512_load_ps(bPtr + 16);
+++ b2Val = _mm512_load_ps(bPtr + 32);
+++ b3Val = _mm512_load_ps(bPtr + 48);
+++
+++ dotProdVal0 = _mm512_fmadd_ps(a0Val, b0Val, dotProdVal0);
+++ dotProdVal1 = _mm512_fmadd_ps(a1Val, b1Val, dotProdVal1);
+++ dotProdVal2 = _mm512_fmadd_ps(a2Val, b2Val, dotProdVal2);
+++ dotProdVal3 = _mm512_fmadd_ps(a3Val, b3Val, dotProdVal3);
+++
+++ aPtr += 64;
+++ bPtr += 64;
+++ }
+++
+++ dotProdVal0 = _mm512_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm512_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm512_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(64) float dotProductVector[16];
+++
+++ _mm512_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
+++ dotProduct += dotProductVector[4];
+++ dotProduct += dotProductVector[5];
+++ dotProduct += dotProductVector[6];
+++ dotProduct += dotProductVector[7];
+++ dotProduct += dotProductVector[8];
+++ dotProduct += dotProductVector[9];
+++ dotProduct += dotProductVector[10];
+++ dotProduct += dotProductVector[11];
+++ dotProduct += dotProductVector[12];
+++ dotProduct += dotProductVector[13];
+++ dotProduct += dotProductVector[14];
+++ dotProduct += dotProductVector[15];
+++
+++ number = sixtyfourthPoints * 64;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = (short)dotProduct;
++ }
++
++ #endif /*LV_HAVE_AVX512F*/
++@@ -367,68 +391,73 @@ static inline void volk_32f_x2_dot_prod_16i_a_avx512f(int16_t* result, const fl
++
++ #ifdef LV_HAVE_SSE
++
++-static inline void volk_32f_x2_dot_prod_16i_u_sse(int16_t* result, const float* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
++-
++- __m128 a0Val, a1Val, a2Val, a3Val;
++- __m128 b0Val, b1Val, b2Val, b3Val;
++- __m128 c0Val, c1Val, c2Val, c3Val;
++-
++- __m128 dotProdVal0 = _mm_setzero_ps();
++- __m128 dotProdVal1 = _mm_setzero_ps();
++- __m128 dotProdVal2 = _mm_setzero_ps();
++- __m128 dotProdVal3 = _mm_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- a0Val = _mm_loadu_ps(aPtr);
++- a1Val = _mm_loadu_ps(aPtr+4);
++- a2Val = _mm_loadu_ps(aPtr+8);
++- a3Val = _mm_loadu_ps(aPtr+12);
++- b0Val = _mm_loadu_ps(bPtr);
++- b1Val = _mm_loadu_ps(bPtr+4);
++- b2Val = _mm_loadu_ps(bPtr+8);
++- b3Val = _mm_loadu_ps(bPtr+12);
++-
++- c0Val = _mm_mul_ps(a0Val, b0Val);
++- c1Val = _mm_mul_ps(a1Val, b1Val);
++- c2Val = _mm_mul_ps(a2Val, b2Val);
++- c3Val = _mm_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
++-
++- aPtr += 16;
++- bPtr += 16;
++- }
++-
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
++-
++- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
++-
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = (short)dotProduct;
+++static inline void volk_32f_x2_dot_prod_16i_u_sse(int16_t* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m128 a0Val, a1Val, a2Val, a3Val;
+++ __m128 b0Val, b1Val, b2Val, b3Val;
+++ __m128 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m128 dotProdVal0 = _mm_setzero_ps();
+++ __m128 dotProdVal1 = _mm_setzero_ps();
+++ __m128 dotProdVal2 = _mm_setzero_ps();
+++ __m128 dotProdVal3 = _mm_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ a0Val = _mm_loadu_ps(aPtr);
+++ a1Val = _mm_loadu_ps(aPtr + 4);
+++ a2Val = _mm_loadu_ps(aPtr + 8);
+++ a3Val = _mm_loadu_ps(aPtr + 12);
+++ b0Val = _mm_loadu_ps(bPtr);
+++ b1Val = _mm_loadu_ps(bPtr + 4);
+++ b2Val = _mm_loadu_ps(bPtr + 8);
+++ b3Val = _mm_loadu_ps(bPtr + 12);
+++
+++ c0Val = _mm_mul_ps(a0Val, b0Val);
+++ c1Val = _mm_mul_ps(a1Val, b1Val);
+++ c2Val = _mm_mul_ps(a2Val, b2Val);
+++ c3Val = _mm_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
+++
+++ aPtr += 16;
+++ bPtr += 16;
+++ }
+++
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
+++
+++ _mm_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = (short)dotProduct;
++ }
++
++ #endif /*LV_HAVE_SSE*/
++@@ -436,66 +465,71 @@ static inline void volk_32f_x2_dot_prod_16i_u_sse(int16_t* result, const float*
++
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++
++-static inline void volk_32f_x2_dot_prod_16i_u_avx2_fma(int16_t* result, const float* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int thirtysecondPoints = num_points / 32;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
++-
++- __m256 a0Val, a1Val, a2Val, a3Val;
++- __m256 b0Val, b1Val, b2Val, b3Val;
++-
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
++- __m256 dotProdVal2 = _mm256_setzero_ps();
++- __m256 dotProdVal3 = _mm256_setzero_ps();
++-
++- for(;number < thirtysecondPoints; number++){
++-
++- a0Val = _mm256_loadu_ps(aPtr);
++- a1Val = _mm256_loadu_ps(aPtr+8);
++- a2Val = _mm256_loadu_ps(aPtr+16);
++- a3Val = _mm256_loadu_ps(aPtr+24);
++- b0Val = _mm256_loadu_ps(bPtr);
++- b1Val = _mm256_loadu_ps(bPtr+8);
++- b2Val = _mm256_loadu_ps(bPtr+16);
++- b3Val = _mm256_loadu_ps(bPtr+24);
++-
++- dotProdVal0 = _mm256_fmadd_ps(a0Val, b0Val, dotProdVal0);
++- dotProdVal1 = _mm256_fmadd_ps(a1Val, b1Val, dotProdVal1);
++- dotProdVal2 = _mm256_fmadd_ps(a2Val, b2Val, dotProdVal2);
++- dotProdVal3 = _mm256_fmadd_ps(a3Val, b3Val, dotProdVal3);
++-
++- aPtr += 32;
++- bPtr += 32;
++- }
++-
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++-
++- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
++- dotProduct += dotProductVector[4];
++- dotProduct += dotProductVector[5];
++- dotProduct += dotProductVector[6];
++- dotProduct += dotProductVector[7];
++-
++- number = thirtysecondPoints*32;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = (short)dotProduct;
+++static inline void volk_32f_x2_dot_prod_16i_u_avx2_fma(int16_t* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int thirtysecondPoints = num_points / 32;
+++
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m256 a0Val, a1Val, a2Val, a3Val;
+++ __m256 b0Val, b1Val, b2Val, b3Val;
+++
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 dotProdVal2 = _mm256_setzero_ps();
+++ __m256 dotProdVal3 = _mm256_setzero_ps();
+++
+++ for (; number < thirtysecondPoints; number++) {
+++
+++ a0Val = _mm256_loadu_ps(aPtr);
+++ a1Val = _mm256_loadu_ps(aPtr + 8);
+++ a2Val = _mm256_loadu_ps(aPtr + 16);
+++ a3Val = _mm256_loadu_ps(aPtr + 24);
+++ b0Val = _mm256_loadu_ps(bPtr);
+++ b1Val = _mm256_loadu_ps(bPtr + 8);
+++ b2Val = _mm256_loadu_ps(bPtr + 16);
+++ b3Val = _mm256_loadu_ps(bPtr + 24);
+++
+++ dotProdVal0 = _mm256_fmadd_ps(a0Val, b0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_fmadd_ps(a1Val, b1Val, dotProdVal1);
+++ dotProdVal2 = _mm256_fmadd_ps(a2Val, b2Val, dotProdVal2);
+++ dotProdVal3 = _mm256_fmadd_ps(a3Val, b3Val, dotProdVal3);
+++
+++ aPtr += 32;
+++ bPtr += 32;
+++ }
+++
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
+++ dotProduct += dotProductVector[4];
+++ dotProduct += dotProductVector[5];
+++ dotProduct += dotProductVector[6];
+++ dotProduct += dotProductVector[7];
+++
+++ number = thirtysecondPoints * 32;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = (short)dotProduct;
++ }
++
++ #endif /*LV_HAVE_AVX2 && lV_HAVE_FMA*/
++@@ -503,146 +537,156 @@ static inline void volk_32f_x2_dot_prod_16i_u_avx2_fma(int16_t* result, const f
++
++ #ifdef LV_HAVE_AVX
++
++-static inline void volk_32f_x2_dot_prod_16i_u_avx(int16_t* result, const float* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int thirtysecondPoints = num_points / 32;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
++-
++- __m256 a0Val, a1Val, a2Val, a3Val;
++- __m256 b0Val, b1Val, b2Val, b3Val;
++- __m256 c0Val, c1Val, c2Val, c3Val;
++-
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
++- __m256 dotProdVal2 = _mm256_setzero_ps();
++- __m256 dotProdVal3 = _mm256_setzero_ps();
++-
++- for(;number < thirtysecondPoints; number++){
++-
++- a0Val = _mm256_loadu_ps(aPtr);
++- a1Val = _mm256_loadu_ps(aPtr+8);
++- a2Val = _mm256_loadu_ps(aPtr+16);
++- a3Val = _mm256_loadu_ps(aPtr+24);
++- b0Val = _mm256_loadu_ps(bPtr);
++- b1Val = _mm256_loadu_ps(bPtr+8);
++- b2Val = _mm256_loadu_ps(bPtr+16);
++- b3Val = _mm256_loadu_ps(bPtr+24);
++-
++- c0Val = _mm256_mul_ps(a0Val, b0Val);
++- c1Val = _mm256_mul_ps(a1Val, b1Val);
++- c2Val = _mm256_mul_ps(a2Val, b2Val);
++- c3Val = _mm256_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm256_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm256_add_ps(c3Val, dotProdVal3);
++-
++- aPtr += 32;
++- bPtr += 32;
++- }
++-
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++-
++- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
++- dotProduct += dotProductVector[4];
++- dotProduct += dotProductVector[5];
++- dotProduct += dotProductVector[6];
++- dotProduct += dotProductVector[7];
++-
++- number = thirtysecondPoints*32;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = (short)dotProduct;
+++static inline void volk_32f_x2_dot_prod_16i_u_avx(int16_t* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int thirtysecondPoints = num_points / 32;
+++
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m256 a0Val, a1Val, a2Val, a3Val;
+++ __m256 b0Val, b1Val, b2Val, b3Val;
+++ __m256 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 dotProdVal2 = _mm256_setzero_ps();
+++ __m256 dotProdVal3 = _mm256_setzero_ps();
+++
+++ for (; number < thirtysecondPoints; number++) {
+++
+++ a0Val = _mm256_loadu_ps(aPtr);
+++ a1Val = _mm256_loadu_ps(aPtr + 8);
+++ a2Val = _mm256_loadu_ps(aPtr + 16);
+++ a3Val = _mm256_loadu_ps(aPtr + 24);
+++ b0Val = _mm256_loadu_ps(bPtr);
+++ b1Val = _mm256_loadu_ps(bPtr + 8);
+++ b2Val = _mm256_loadu_ps(bPtr + 16);
+++ b3Val = _mm256_loadu_ps(bPtr + 24);
+++
+++ c0Val = _mm256_mul_ps(a0Val, b0Val);
+++ c1Val = _mm256_mul_ps(a1Val, b1Val);
+++ c2Val = _mm256_mul_ps(a2Val, b2Val);
+++ c3Val = _mm256_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm256_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm256_add_ps(c3Val, dotProdVal3);
+++
+++ aPtr += 32;
+++ bPtr += 32;
+++ }
+++
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
+++ dotProduct += dotProductVector[4];
+++ dotProduct += dotProductVector[5];
+++ dotProduct += dotProductVector[6];
+++ dotProduct += dotProductVector[7];
+++
+++ number = thirtysecondPoints * 32;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = (short)dotProduct;
++ }
++
++ #endif /*LV_HAVE_AVX*/
++
++ #ifdef LV_HAVE_AVX512F
++
++-static inline void volk_32f_x2_dot_prod_16i_u_avx512f(int16_t* result, const float* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixtyfourthPoints = num_points / 64;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
++-
++- __m512 a0Val, a1Val, a2Val, a3Val;
++- __m512 b0Val, b1Val, b2Val, b3Val;
++-
++- __m512 dotProdVal0 = _mm512_setzero_ps();
++- __m512 dotProdVal1 = _mm512_setzero_ps();
++- __m512 dotProdVal2 = _mm512_setzero_ps();
++- __m512 dotProdVal3 = _mm512_setzero_ps();
++-
++- for(;number < sixtyfourthPoints; number++){
++-
++- a0Val = _mm512_loadu_ps(aPtr);
++- a1Val = _mm512_loadu_ps(aPtr+16);
++- a2Val = _mm512_loadu_ps(aPtr+32);
++- a3Val = _mm512_loadu_ps(aPtr+48);
++- b0Val = _mm512_loadu_ps(bPtr);
++- b1Val = _mm512_loadu_ps(bPtr+16);
++- b2Val = _mm512_loadu_ps(bPtr+32);
++- b3Val = _mm512_loadu_ps(bPtr+48);
++-
++- dotProdVal0 = _mm512_fmadd_ps(a0Val, b0Val, dotProdVal0);
++- dotProdVal1 = _mm512_fmadd_ps(a1Val, b1Val, dotProdVal1);
++- dotProdVal2 = _mm512_fmadd_ps(a2Val, b2Val, dotProdVal2);
++- dotProdVal3 = _mm512_fmadd_ps(a3Val, b3Val, dotProdVal3);
++-
++- aPtr += 64;
++- bPtr += 64;
++- }
++-
++- dotProdVal0 = _mm512_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm512_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm512_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(64) float dotProductVector[16];
++-
++- _mm512_storeu_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
++- dotProduct += dotProductVector[4];
++- dotProduct += dotProductVector[5];
++- dotProduct += dotProductVector[6];
++- dotProduct += dotProductVector[7];
++- dotProduct += dotProductVector[8];
++- dotProduct += dotProductVector[9];
++- dotProduct += dotProductVector[10];
++- dotProduct += dotProductVector[11];
++- dotProduct += dotProductVector[12];
++- dotProduct += dotProductVector[13];
++- dotProduct += dotProductVector[14];
++- dotProduct += dotProductVector[15];
++-
++- number = sixtyfourthPoints*64;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = (short)dotProduct;
+++static inline void volk_32f_x2_dot_prod_16i_u_avx512f(int16_t* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixtyfourthPoints = num_points / 64;
+++
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m512 a0Val, a1Val, a2Val, a3Val;
+++ __m512 b0Val, b1Val, b2Val, b3Val;
+++
+++ __m512 dotProdVal0 = _mm512_setzero_ps();
+++ __m512 dotProdVal1 = _mm512_setzero_ps();
+++ __m512 dotProdVal2 = _mm512_setzero_ps();
+++ __m512 dotProdVal3 = _mm512_setzero_ps();
+++
+++ for (; number < sixtyfourthPoints; number++) {
+++
+++ a0Val = _mm512_loadu_ps(aPtr);
+++ a1Val = _mm512_loadu_ps(aPtr + 16);
+++ a2Val = _mm512_loadu_ps(aPtr + 32);
+++ a3Val = _mm512_loadu_ps(aPtr + 48);
+++ b0Val = _mm512_loadu_ps(bPtr);
+++ b1Val = _mm512_loadu_ps(bPtr + 16);
+++ b2Val = _mm512_loadu_ps(bPtr + 32);
+++ b3Val = _mm512_loadu_ps(bPtr + 48);
+++
+++ dotProdVal0 = _mm512_fmadd_ps(a0Val, b0Val, dotProdVal0);
+++ dotProdVal1 = _mm512_fmadd_ps(a1Val, b1Val, dotProdVal1);
+++ dotProdVal2 = _mm512_fmadd_ps(a2Val, b2Val, dotProdVal2);
+++ dotProdVal3 = _mm512_fmadd_ps(a3Val, b3Val, dotProdVal3);
+++
+++ aPtr += 64;
+++ bPtr += 64;
+++ }
+++
+++ dotProdVal0 = _mm512_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm512_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm512_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(64) float dotProductVector[16];
+++
+++ _mm512_storeu_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
+++ dotProduct += dotProductVector[4];
+++ dotProduct += dotProductVector[5];
+++ dotProduct += dotProductVector[6];
+++ dotProduct += dotProductVector[7];
+++ dotProduct += dotProductVector[8];
+++ dotProduct += dotProductVector[9];
+++ dotProduct += dotProductVector[10];
+++ dotProduct += dotProductVector[11];
+++ dotProduct += dotProductVector[12];
+++ dotProduct += dotProductVector[13];
+++ dotProduct += dotProductVector[14];
+++ dotProduct += dotProductVector[15];
+++
+++ number = sixtyfourthPoints * 64;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = (short)dotProduct;
++ }
++
++ #endif /*LV_HAVE_AVX512F*/
++diff --git a/kernels/volk/volk_32f_x2_dot_prod_32f.h b/kernels/volk/volk_32f_x2_dot_prod_32f.h
++index ea0f7ba..7854031 100644
++--- a/kernels/volk/volk_32f_x2_dot_prod_32f.h
+++++ b/kernels/volk/volk_32f_x2_dot_prod_32f.h
++@@ -33,8 +33,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_x2_dot_prod_32f(float* result, const float* input, const float* taps, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_x2_dot_prod_32f(float* result, const float* input, const float* taps,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li input: vector of floats.
++@@ -45,10 +45,8 @@
++ * \li result: pointer to a float value to hold the dot product result.
++ *
++ * \b Example
++- * Take the dot product of an increasing vector and a vector of ones. The result is the sum of integers (0,9).
++- * \code
++- * int N = 10;
++- * unsigned int alignment = volk_get_alignment();
+++ * Take the dot product of an increasing vector and a vector of ones. The result is the
+++ * sum of integers (0,9). \code int N = 10; unsigned int alignment = volk_get_alignment();
++ * float* increasing = (float*)volk_malloc(sizeof(float)*N, alignment);
++ * float* ones = (float*)volk_malloc(sizeof(float)*N, alignment);
++ * float* out = (float*)volk_malloc(sizeof(float)*1, alignment);
++@@ -73,25 +71,29 @@
++ #ifndef INCLUDED_volk_32f_x2_dot_prod_32f_u_H
++ #define INCLUDED_volk_32f_x2_dot_prod_32f_u_H
++
+++#include <stdio.h>
++ #include <volk/volk_common.h>
++-#include<stdio.h>
++
++
++ #ifdef LV_HAVE_GENERIC
++
++
++-static inline void volk_32f_x2_dot_prod_32f_generic(float * result, const float * input, const float * taps, unsigned int num_points) {
+++static inline void volk_32f_x2_dot_prod_32f_generic(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
++
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr= taps;
++- unsigned int number = 0;
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
+++ for (number = 0; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
++- *result = dotProduct;
+++ *result = dotProduct;
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -100,69 +102,73 @@ static inline void volk_32f_x2_dot_prod_32f_generic(float * result, const float
++ #ifdef LV_HAVE_SSE
++
++
++-static inline void volk_32f_x2_dot_prod_32f_u_sse( float* result, const float* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
+++static inline void volk_32f_x2_dot_prod_32f_u_sse(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
++
++- __m128 a0Val, a1Val, a2Val, a3Val;
++- __m128 b0Val, b1Val, b2Val, b3Val;
++- __m128 c0Val, c1Val, c2Val, c3Val;
++-
++- __m128 dotProdVal0 = _mm_setzero_ps();
++- __m128 dotProdVal1 = _mm_setzero_ps();
++- __m128 dotProdVal2 = _mm_setzero_ps();
++- __m128 dotProdVal3 = _mm_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- a0Val = _mm_loadu_ps(aPtr);
++- a1Val = _mm_loadu_ps(aPtr+4);
++- a2Val = _mm_loadu_ps(aPtr+8);
++- a3Val = _mm_loadu_ps(aPtr+12);
++- b0Val = _mm_loadu_ps(bPtr);
++- b1Val = _mm_loadu_ps(bPtr+4);
++- b2Val = _mm_loadu_ps(bPtr+8);
++- b3Val = _mm_loadu_ps(bPtr+12);
++-
++- c0Val = _mm_mul_ps(a0Val, b0Val);
++- c1Val = _mm_mul_ps(a1Val, b1Val);
++- c2Val = _mm_mul_ps(a2Val, b2Val);
++- c3Val = _mm_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- aPtr += 16;
++- bPtr += 16;
++- }
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m128 a0Val, a1Val, a2Val, a3Val;
+++ __m128 b0Val, b1Val, b2Val, b3Val;
+++ __m128 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m128 dotProdVal0 = _mm_setzero_ps();
+++ __m128 dotProdVal1 = _mm_setzero_ps();
+++ __m128 dotProdVal2 = _mm_setzero_ps();
+++ __m128 dotProdVal3 = _mm_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ a0Val = _mm_loadu_ps(aPtr);
+++ a1Val = _mm_loadu_ps(aPtr + 4);
+++ a2Val = _mm_loadu_ps(aPtr + 8);
+++ a3Val = _mm_loadu_ps(aPtr + 12);
+++ b0Val = _mm_loadu_ps(bPtr);
+++ b1Val = _mm_loadu_ps(bPtr + 4);
+++ b2Val = _mm_loadu_ps(bPtr + 8);
+++ b3Val = _mm_loadu_ps(bPtr + 12);
+++
+++ c0Val = _mm_mul_ps(a0Val, b0Val);
+++ c1Val = _mm_mul_ps(a1Val, b1Val);
+++ c2Val = _mm_mul_ps(a2Val, b2Val);
+++ c3Val = _mm_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
++
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
+++ aPtr += 16;
+++ bPtr += 16;
+++ }
++
++- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
++
++- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
+++ __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
++
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
+++ _mm_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
++
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
++
++- *result = dotProduct;
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
+++ *result = dotProduct;
++ }
++
++ #endif /*LV_HAVE_SSE*/
++@@ -171,127 +177,145 @@ static inline void volk_32f_x2_dot_prod_32f_u_sse( float* result, const float*
++
++ #include <pmmintrin.h>
++
++-static inline void volk_32f_x2_dot_prod_32f_u_sse3(float * result, const float * input, const float * taps, unsigned int num_points) {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
++-
++- __m128 a0Val, a1Val, a2Val, a3Val;
++- __m128 b0Val, b1Val, b2Val, b3Val;
++- __m128 c0Val, c1Val, c2Val, c3Val;
++-
++- __m128 dotProdVal0 = _mm_setzero_ps();
++- __m128 dotProdVal1 = _mm_setzero_ps();
++- __m128 dotProdVal2 = _mm_setzero_ps();
++- __m128 dotProdVal3 = _mm_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- a0Val = _mm_loadu_ps(aPtr);
++- a1Val = _mm_loadu_ps(aPtr+4);
++- a2Val = _mm_loadu_ps(aPtr+8);
++- a3Val = _mm_loadu_ps(aPtr+12);
++- b0Val = _mm_loadu_ps(bPtr);
++- b1Val = _mm_loadu_ps(bPtr+4);
++- b2Val = _mm_loadu_ps(bPtr+8);
++- b3Val = _mm_loadu_ps(bPtr+12);
++-
++- c0Val = _mm_mul_ps(a0Val, b0Val);
++- c1Val = _mm_mul_ps(a1Val, b1Val);
++- c2Val = _mm_mul_ps(a2Val, b2Val);
++- c3Val = _mm_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm_add_ps(dotProdVal0, c0Val);
++- dotProdVal1 = _mm_add_ps(dotProdVal1, c1Val);
++- dotProdVal2 = _mm_add_ps(dotProdVal2, c2Val);
++- dotProdVal3 = _mm_add_ps(dotProdVal3, c3Val);
++-
++- aPtr += 16;
++- bPtr += 16;
++- }
++-
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
++- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
++-
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = dotProduct;
++-}
++-
++-#endif /*LV_HAVE_SSE3*/
+++static inline void volk_32f_x2_dot_prod_32f_u_sse3(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++-#ifdef LV_HAVE_SSE4_1
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m128 a0Val, a1Val, a2Val, a3Val;
+++ __m128 b0Val, b1Val, b2Val, b3Val;
+++ __m128 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m128 dotProdVal0 = _mm_setzero_ps();
+++ __m128 dotProdVal1 = _mm_setzero_ps();
+++ __m128 dotProdVal2 = _mm_setzero_ps();
+++ __m128 dotProdVal3 = _mm_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ a0Val = _mm_loadu_ps(aPtr);
+++ a1Val = _mm_loadu_ps(aPtr + 4);
+++ a2Val = _mm_loadu_ps(aPtr + 8);
+++ a3Val = _mm_loadu_ps(aPtr + 12);
+++ b0Val = _mm_loadu_ps(bPtr);
+++ b1Val = _mm_loadu_ps(bPtr + 4);
+++ b2Val = _mm_loadu_ps(bPtr + 8);
+++ b3Val = _mm_loadu_ps(bPtr + 12);
+++
+++ c0Val = _mm_mul_ps(a0Val, b0Val);
+++ c1Val = _mm_mul_ps(a1Val, b1Val);
+++ c2Val = _mm_mul_ps(a2Val, b2Val);
+++ c3Val = _mm_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, c0Val);
+++ dotProdVal1 = _mm_add_ps(dotProdVal1, c1Val);
+++ dotProdVal2 = _mm_add_ps(dotProdVal2, c2Val);
+++ dotProdVal3 = _mm_add_ps(dotProdVal3, c3Val);
++
++-#include <smmintrin.h>
+++ aPtr += 16;
+++ bPtr += 16;
+++ }
++
++-static inline void volk_32f_x2_dot_prod_32f_u_sse4_1(float * result, const float * input, const float* taps, unsigned int num_points) {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
++
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
+++ __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
+++ _mm_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
++
++- __m128 aVal1, bVal1, cVal1;
++- __m128 aVal2, bVal2, cVal2;
++- __m128 aVal3, bVal3, cVal3;
++- __m128 aVal4, bVal4, cVal4;
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
++
++- __m128 dotProdVal = _mm_setzero_ps();
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
++- for(;number < sixteenthPoints; number++){
+++ *result = dotProduct;
+++}
++
++- aVal1 = _mm_loadu_ps(aPtr); aPtr += 4;
++- aVal2 = _mm_loadu_ps(aPtr); aPtr += 4;
++- aVal3 = _mm_loadu_ps(aPtr); aPtr += 4;
++- aVal4 = _mm_loadu_ps(aPtr); aPtr += 4;
+++#endif /*LV_HAVE_SSE3*/
++
++- bVal1 = _mm_loadu_ps(bPtr); bPtr += 4;
++- bVal2 = _mm_loadu_ps(bPtr); bPtr += 4;
++- bVal3 = _mm_loadu_ps(bPtr); bPtr += 4;
++- bVal4 = _mm_loadu_ps(bPtr); bPtr += 4;
+++#ifdef LV_HAVE_SSE4_1
++
++- cVal1 = _mm_dp_ps(aVal1, bVal1, 0xF1);
++- cVal2 = _mm_dp_ps(aVal2, bVal2, 0xF2);
++- cVal3 = _mm_dp_ps(aVal3, bVal3, 0xF4);
++- cVal4 = _mm_dp_ps(aVal4, bVal4, 0xF8);
+++#include <smmintrin.h>
++
++- cVal1 = _mm_or_ps(cVal1, cVal2);
++- cVal3 = _mm_or_ps(cVal3, cVal4);
++- cVal1 = _mm_or_ps(cVal1, cVal3);
+++static inline void volk_32f_x2_dot_prod_32f_u_sse4_1(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- dotProdVal = _mm_add_ps(dotProdVal, cVal1);
++- }
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m128 aVal1, bVal1, cVal1;
+++ __m128 aVal2, bVal2, cVal2;
+++ __m128 aVal3, bVal3, cVal3;
+++ __m128 aVal4, bVal4, cVal4;
+++
+++ __m128 dotProdVal = _mm_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ aVal1 = _mm_loadu_ps(aPtr);
+++ aPtr += 4;
+++ aVal2 = _mm_loadu_ps(aPtr);
+++ aPtr += 4;
+++ aVal3 = _mm_loadu_ps(aPtr);
+++ aPtr += 4;
+++ aVal4 = _mm_loadu_ps(aPtr);
+++ aPtr += 4;
+++
+++ bVal1 = _mm_loadu_ps(bPtr);
+++ bPtr += 4;
+++ bVal2 = _mm_loadu_ps(bPtr);
+++ bPtr += 4;
+++ bVal3 = _mm_loadu_ps(bPtr);
+++ bPtr += 4;
+++ bVal4 = _mm_loadu_ps(bPtr);
+++ bPtr += 4;
+++
+++ cVal1 = _mm_dp_ps(aVal1, bVal1, 0xF1);
+++ cVal2 = _mm_dp_ps(aVal2, bVal2, 0xF2);
+++ cVal3 = _mm_dp_ps(aVal3, bVal3, 0xF4);
+++ cVal4 = _mm_dp_ps(aVal4, bVal4, 0xF8);
+++
+++ cVal1 = _mm_or_ps(cVal1, cVal2);
+++ cVal3 = _mm_or_ps(cVal3, cVal4);
+++ cVal1 = _mm_or_ps(cVal1, cVal3);
+++
+++ dotProdVal = _mm_add_ps(dotProdVal, cVal1);
+++ }
++
++- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
++- _mm_store_ps(dotProductVector, dotProdVal); // Store the results back into the dot product vector
+++ __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
+++ _mm_store_ps(dotProductVector,
+++ dotProdVal); // Store the results back into the dot product vector
++
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
++- *result = dotProduct;
+++ *result = dotProduct;
++ }
++
++ #endif /*LV_HAVE_SSE4_1*/
++@@ -300,147 +324,154 @@ static inline void volk_32f_x2_dot_prod_32f_u_sse4_1(float * result, const float
++
++ #include <immintrin.h>
++
++-static inline void volk_32f_x2_dot_prod_32f_u_avx( float* result, const float* input, const float* taps, unsigned int num_points) {
+++static inline void volk_32f_x2_dot_prod_32f_u_avx(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
++
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- __m256 a0Val, a1Val;
++- __m256 b0Val, b1Val;
++- __m256 c0Val, c1Val;
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
++
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 a0Val, a1Val;
+++ __m256 b0Val, b1Val;
+++ __m256 c0Val, c1Val;
++
++- for(;number < sixteenthPoints; number++){
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
++
++- a0Val = _mm256_loadu_ps(aPtr);
++- a1Val = _mm256_loadu_ps(aPtr+8);
++- b0Val = _mm256_loadu_ps(bPtr);
++- b1Val = _mm256_loadu_ps(bPtr+8);
+++ for (; number < sixteenthPoints; number++) {
++
++- c0Val = _mm256_mul_ps(a0Val, b0Val);
++- c1Val = _mm256_mul_ps(a1Val, b1Val);
+++ a0Val = _mm256_loadu_ps(aPtr);
+++ a1Val = _mm256_loadu_ps(aPtr + 8);
+++ b0Val = _mm256_loadu_ps(bPtr);
+++ b1Val = _mm256_loadu_ps(bPtr + 8);
++
++- dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
+++ c0Val = _mm256_mul_ps(a0Val, b0Val);
+++ c1Val = _mm256_mul_ps(a1Val, b1Val);
++
++- aPtr += 16;
++- bPtr += 16;
++- }
+++ dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
++
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ aPtr += 16;
+++ bPtr += 16;
+++ }
++
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++
++- _mm256_storeu_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
++- dotProduct += dotProductVector[4];
++- dotProduct += dotProductVector[5];
++- dotProduct += dotProductVector[6];
++- dotProduct += dotProductVector[7];
+++ _mm256_storeu_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
++
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
+++ dotProduct += dotProductVector[4];
+++ dotProduct += dotProductVector[5];
+++ dotProduct += dotProductVector[6];
+++ dotProduct += dotProductVector[7];
++
++- *result = dotProduct;
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
+++ *result = dotProduct;
++ }
++
++ #endif /*LV_HAVE_AVX*/
++
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++ #include <immintrin.h>
++-static inline void volk_32f_x2_dot_prod_32f_u_avx2_fma(float * result, const float * input, const float* taps, unsigned int num_points){
++- unsigned int number;
++- const unsigned int eighthPoints = num_points / 8;
+++static inline void volk_32f_x2_dot_prod_32f_u_avx2_fma(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++ unsigned int number;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- const float* aPtr = input;
++- const float* bPtr = taps;
++-
++- __m256 dotProdVal = _mm256_setzero_ps();
++- __m256 aVal1, bVal1;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
++
++- for (number = 0; number < eighthPoints; number++ ) {
+++ __m256 dotProdVal = _mm256_setzero_ps();
+++ __m256 aVal1, bVal1;
++
++- aVal1 = _mm256_loadu_ps(aPtr);
++- bVal1 = _mm256_loadu_ps(bPtr);
++- aPtr += 8;
++- bPtr += 8;
+++ for (number = 0; number < eighthPoints; number++) {
++
++- dotProdVal = _mm256_fmadd_ps(aVal1, bVal1, dotProdVal);
++- }
+++ aVal1 = _mm256_loadu_ps(aPtr);
+++ bVal1 = _mm256_loadu_ps(bPtr);
+++ aPtr += 8;
+++ bPtr += 8;
++
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++- _mm256_storeu_ps(dotProductVector, dotProdVal); // Store the results back into the dot product vector
++- _mm256_zeroupper();
+++ dotProdVal = _mm256_fmadd_ps(aVal1, bVal1, dotProdVal);
+++ }
++
++- float dotProduct =
++- dotProductVector[0] + dotProductVector[1] +
++- dotProductVector[2] + dotProductVector[3] +
++- dotProductVector[4] + dotProductVector[5] +
++- dotProductVector[6] + dotProductVector[7];
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++ _mm256_storeu_ps(dotProductVector,
+++ dotProdVal); // Store the results back into the dot product vector
+++ _mm256_zeroupper();
++
++- for(number = eighthPoints * 8; number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
+++ float dotProduct = dotProductVector[0] + dotProductVector[1] + dotProductVector[2] +
+++ dotProductVector[3] + dotProductVector[4] + dotProductVector[5] +
+++ dotProductVector[6] + dotProductVector[7];
++
++- *result = dotProduct;
+++ for (number = eighthPoints * 8; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
+++ *result = dotProduct;
++ }
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA */
++
++ #if LV_HAVE_AVX512F
++ #include <immintrin.h>
++-static inline void volk_32f_x2_dot_prod_32f_u_avx512f(float * result, const float * input, const float* taps, unsigned int num_points){
++- unsigned int number;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- const float* aPtr = input;
++- const float* bPtr = taps;
+++static inline void volk_32f_x2_dot_prod_32f_u_avx512f(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++ unsigned int number;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- __m512 dotProdVal = _mm512_setzero_ps();
++- __m512 aVal1, bVal1;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
++
++- for (number = 0; number < sixteenthPoints; number++ ) {
+++ __m512 dotProdVal = _mm512_setzero_ps();
+++ __m512 aVal1, bVal1;
++
++- aVal1 = _mm512_loadu_ps(aPtr);
++- bVal1 = _mm512_loadu_ps(bPtr);
++- aPtr += 16;
++- bPtr += 16;
+++ for (number = 0; number < sixteenthPoints; number++) {
++
++- dotProdVal = _mm512_fmadd_ps(aVal1, bVal1, dotProdVal);
++- }
+++ aVal1 = _mm512_loadu_ps(aPtr);
+++ bVal1 = _mm512_loadu_ps(bPtr);
+++ aPtr += 16;
+++ bPtr += 16;
++
++- __VOLK_ATTR_ALIGNED(64) float dotProductVector[16];
++- _mm512_storeu_ps(dotProductVector, dotProdVal); // Store the results back into the dot product vector
+++ dotProdVal = _mm512_fmadd_ps(aVal1, bVal1, dotProdVal);
+++ }
++
++- float dotProduct =
++- dotProductVector[0] + dotProductVector[1] +
++- dotProductVector[2] + dotProductVector[3] +
++- dotProductVector[4] + dotProductVector[5] +
++- dotProductVector[6] + dotProductVector[7] +
++- dotProductVector[8] + dotProductVector[9] +
++- dotProductVector[10] + dotProductVector[11] +
++- dotProductVector[12] + dotProductVector[13] +
++- dotProductVector[14] + dotProductVector[15];
+++ __VOLK_ATTR_ALIGNED(64) float dotProductVector[16];
+++ _mm512_storeu_ps(dotProductVector,
+++ dotProdVal); // Store the results back into the dot product vector
++
++- for(number = sixteenthPoints * 16; number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
+++ float dotProduct = dotProductVector[0] + dotProductVector[1] + dotProductVector[2] +
+++ dotProductVector[3] + dotProductVector[4] + dotProductVector[5] +
+++ dotProductVector[6] + dotProductVector[7] + dotProductVector[8] +
+++ dotProductVector[9] + dotProductVector[10] + dotProductVector[11] +
+++ dotProductVector[12] + dotProductVector[13] +
+++ dotProductVector[14] + dotProductVector[15];
++
++- *result = dotProduct;
+++ for (number = sixteenthPoints * 16; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
+++ *result = dotProduct;
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++@@ -449,25 +480,29 @@ static inline void volk_32f_x2_dot_prod_32f_u_avx512f(float * result, const floa
++ #ifndef INCLUDED_volk_32f_x2_dot_prod_32f_a_H
++ #define INCLUDED_volk_32f_x2_dot_prod_32f_a_H
++
+++#include <stdio.h>
++ #include <volk/volk_common.h>
++-#include<stdio.h>
++
++
++ #ifdef LV_HAVE_GENERIC
++
++
++-static inline void volk_32f_x2_dot_prod_32f_a_generic(float * result, const float * input, const float * taps, unsigned int num_points) {
+++static inline void volk_32f_x2_dot_prod_32f_a_generic(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
++
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr= taps;
++- unsigned int number = 0;
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
+++ for (number = 0; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
++- *result = dotProduct;
+++ *result = dotProduct;
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -476,69 +511,73 @@ static inline void volk_32f_x2_dot_prod_32f_a_generic(float * result, const floa
++ #ifdef LV_HAVE_SSE
++
++
++-static inline void volk_32f_x2_dot_prod_32f_a_sse( float* result, const float* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
++-
++- __m128 a0Val, a1Val, a2Val, a3Val;
++- __m128 b0Val, b1Val, b2Val, b3Val;
++- __m128 c0Val, c1Val, c2Val, c3Val;
++-
++- __m128 dotProdVal0 = _mm_setzero_ps();
++- __m128 dotProdVal1 = _mm_setzero_ps();
++- __m128 dotProdVal2 = _mm_setzero_ps();
++- __m128 dotProdVal3 = _mm_setzero_ps();
+++static inline void volk_32f_x2_dot_prod_32f_a_sse(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
++
++- for(;number < sixteenthPoints; number++){
++-
++- a0Val = _mm_load_ps(aPtr);
++- a1Val = _mm_load_ps(aPtr+4);
++- a2Val = _mm_load_ps(aPtr+8);
++- a3Val = _mm_load_ps(aPtr+12);
++- b0Val = _mm_load_ps(bPtr);
++- b1Val = _mm_load_ps(bPtr+4);
++- b2Val = _mm_load_ps(bPtr+8);
++- b3Val = _mm_load_ps(bPtr+12);
++-
++- c0Val = _mm_mul_ps(a0Val, b0Val);
++- c1Val = _mm_mul_ps(a1Val, b1Val);
++- c2Val = _mm_mul_ps(a2Val, b2Val);
++- c3Val = _mm_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- aPtr += 16;
++- bPtr += 16;
++- }
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m128 a0Val, a1Val, a2Val, a3Val;
+++ __m128 b0Val, b1Val, b2Val, b3Val;
+++ __m128 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m128 dotProdVal0 = _mm_setzero_ps();
+++ __m128 dotProdVal1 = _mm_setzero_ps();
+++ __m128 dotProdVal2 = _mm_setzero_ps();
+++ __m128 dotProdVal3 = _mm_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ a0Val = _mm_load_ps(aPtr);
+++ a1Val = _mm_load_ps(aPtr + 4);
+++ a2Val = _mm_load_ps(aPtr + 8);
+++ a3Val = _mm_load_ps(aPtr + 12);
+++ b0Val = _mm_load_ps(bPtr);
+++ b1Val = _mm_load_ps(bPtr + 4);
+++ b2Val = _mm_load_ps(bPtr + 8);
+++ b3Val = _mm_load_ps(bPtr + 12);
+++
+++ c0Val = _mm_mul_ps(a0Val, b0Val);
+++ c1Val = _mm_mul_ps(a1Val, b1Val);
+++ c2Val = _mm_mul_ps(a2Val, b2Val);
+++ c3Val = _mm_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
++
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
+++ aPtr += 16;
+++ bPtr += 16;
+++ }
++
++- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
++
++- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
+++ __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
++
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
+++ _mm_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
++
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
++
++- *result = dotProduct;
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
+++ *result = dotProduct;
++ }
++
++ #endif /*LV_HAVE_SSE*/
++@@ -547,127 +586,145 @@ static inline void volk_32f_x2_dot_prod_32f_a_sse( float* result, const float*
++
++ #include <pmmintrin.h>
++
++-static inline void volk_32f_x2_dot_prod_32f_a_sse3(float * result, const float * input, const float * taps, unsigned int num_points) {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
++-
++- __m128 a0Val, a1Val, a2Val, a3Val;
++- __m128 b0Val, b1Val, b2Val, b3Val;
++- __m128 c0Val, c1Val, c2Val, c3Val;
++-
++- __m128 dotProdVal0 = _mm_setzero_ps();
++- __m128 dotProdVal1 = _mm_setzero_ps();
++- __m128 dotProdVal2 = _mm_setzero_ps();
++- __m128 dotProdVal3 = _mm_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- a0Val = _mm_load_ps(aPtr);
++- a1Val = _mm_load_ps(aPtr+4);
++- a2Val = _mm_load_ps(aPtr+8);
++- a3Val = _mm_load_ps(aPtr+12);
++- b0Val = _mm_load_ps(bPtr);
++- b1Val = _mm_load_ps(bPtr+4);
++- b2Val = _mm_load_ps(bPtr+8);
++- b3Val = _mm_load_ps(bPtr+12);
++-
++- c0Val = _mm_mul_ps(a0Val, b0Val);
++- c1Val = _mm_mul_ps(a1Val, b1Val);
++- c2Val = _mm_mul_ps(a2Val, b2Val);
++- c3Val = _mm_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm_add_ps(dotProdVal0, c0Val);
++- dotProdVal1 = _mm_add_ps(dotProdVal1, c1Val);
++- dotProdVal2 = _mm_add_ps(dotProdVal2, c2Val);
++- dotProdVal3 = _mm_add_ps(dotProdVal3, c3Val);
++-
++- aPtr += 16;
++- bPtr += 16;
++- }
++-
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
++- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
++-
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = dotProduct;
++-}
++-
++-#endif /*LV_HAVE_SSE3*/
+++static inline void volk_32f_x2_dot_prod_32f_a_sse3(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++-#ifdef LV_HAVE_SSE4_1
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m128 a0Val, a1Val, a2Val, a3Val;
+++ __m128 b0Val, b1Val, b2Val, b3Val;
+++ __m128 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m128 dotProdVal0 = _mm_setzero_ps();
+++ __m128 dotProdVal1 = _mm_setzero_ps();
+++ __m128 dotProdVal2 = _mm_setzero_ps();
+++ __m128 dotProdVal3 = _mm_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ a0Val = _mm_load_ps(aPtr);
+++ a1Val = _mm_load_ps(aPtr + 4);
+++ a2Val = _mm_load_ps(aPtr + 8);
+++ a3Val = _mm_load_ps(aPtr + 12);
+++ b0Val = _mm_load_ps(bPtr);
+++ b1Val = _mm_load_ps(bPtr + 4);
+++ b2Val = _mm_load_ps(bPtr + 8);
+++ b3Val = _mm_load_ps(bPtr + 12);
+++
+++ c0Val = _mm_mul_ps(a0Val, b0Val);
+++ c1Val = _mm_mul_ps(a1Val, b1Val);
+++ c2Val = _mm_mul_ps(a2Val, b2Val);
+++ c3Val = _mm_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, c0Val);
+++ dotProdVal1 = _mm_add_ps(dotProdVal1, c1Val);
+++ dotProdVal2 = _mm_add_ps(dotProdVal2, c2Val);
+++ dotProdVal3 = _mm_add_ps(dotProdVal3, c3Val);
++
++-#include <smmintrin.h>
+++ aPtr += 16;
+++ bPtr += 16;
+++ }
++
++-static inline void volk_32f_x2_dot_prod_32f_a_sse4_1(float * result, const float * input, const float* taps, unsigned int num_points) {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
++
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
+++ __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
+++ _mm_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
++
++- __m128 aVal1, bVal1, cVal1;
++- __m128 aVal2, bVal2, cVal2;
++- __m128 aVal3, bVal3, cVal3;
++- __m128 aVal4, bVal4, cVal4;
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
++
++- __m128 dotProdVal = _mm_setzero_ps();
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
++- for(;number < sixteenthPoints; number++){
+++ *result = dotProduct;
+++}
++
++- aVal1 = _mm_load_ps(aPtr); aPtr += 4;
++- aVal2 = _mm_load_ps(aPtr); aPtr += 4;
++- aVal3 = _mm_load_ps(aPtr); aPtr += 4;
++- aVal4 = _mm_load_ps(aPtr); aPtr += 4;
+++#endif /*LV_HAVE_SSE3*/
++
++- bVal1 = _mm_load_ps(bPtr); bPtr += 4;
++- bVal2 = _mm_load_ps(bPtr); bPtr += 4;
++- bVal3 = _mm_load_ps(bPtr); bPtr += 4;
++- bVal4 = _mm_load_ps(bPtr); bPtr += 4;
+++#ifdef LV_HAVE_SSE4_1
++
++- cVal1 = _mm_dp_ps(aVal1, bVal1, 0xF1);
++- cVal2 = _mm_dp_ps(aVal2, bVal2, 0xF2);
++- cVal3 = _mm_dp_ps(aVal3, bVal3, 0xF4);
++- cVal4 = _mm_dp_ps(aVal4, bVal4, 0xF8);
+++#include <smmintrin.h>
++
++- cVal1 = _mm_or_ps(cVal1, cVal2);
++- cVal3 = _mm_or_ps(cVal3, cVal4);
++- cVal1 = _mm_or_ps(cVal1, cVal3);
+++static inline void volk_32f_x2_dot_prod_32f_a_sse4_1(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- dotProdVal = _mm_add_ps(dotProdVal, cVal1);
++- }
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
+++
+++ __m128 aVal1, bVal1, cVal1;
+++ __m128 aVal2, bVal2, cVal2;
+++ __m128 aVal3, bVal3, cVal3;
+++ __m128 aVal4, bVal4, cVal4;
+++
+++ __m128 dotProdVal = _mm_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ aVal1 = _mm_load_ps(aPtr);
+++ aPtr += 4;
+++ aVal2 = _mm_load_ps(aPtr);
+++ aPtr += 4;
+++ aVal3 = _mm_load_ps(aPtr);
+++ aPtr += 4;
+++ aVal4 = _mm_load_ps(aPtr);
+++ aPtr += 4;
+++
+++ bVal1 = _mm_load_ps(bPtr);
+++ bPtr += 4;
+++ bVal2 = _mm_load_ps(bPtr);
+++ bPtr += 4;
+++ bVal3 = _mm_load_ps(bPtr);
+++ bPtr += 4;
+++ bVal4 = _mm_load_ps(bPtr);
+++ bPtr += 4;
+++
+++ cVal1 = _mm_dp_ps(aVal1, bVal1, 0xF1);
+++ cVal2 = _mm_dp_ps(aVal2, bVal2, 0xF2);
+++ cVal3 = _mm_dp_ps(aVal3, bVal3, 0xF4);
+++ cVal4 = _mm_dp_ps(aVal4, bVal4, 0xF8);
+++
+++ cVal1 = _mm_or_ps(cVal1, cVal2);
+++ cVal3 = _mm_or_ps(cVal3, cVal4);
+++ cVal1 = _mm_or_ps(cVal1, cVal3);
+++
+++ dotProdVal = _mm_add_ps(dotProdVal, cVal1);
+++ }
++
++- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
++- _mm_store_ps(dotProductVector, dotProdVal); // Store the results back into the dot product vector
+++ __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
+++ _mm_store_ps(dotProductVector,
+++ dotProdVal); // Store the results back into the dot product vector
++
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
++- *result = dotProduct;
+++ *result = dotProduct;
++ }
++
++ #endif /*LV_HAVE_SSE4_1*/
++@@ -676,159 +733,170 @@ static inline void volk_32f_x2_dot_prod_32f_a_sse4_1(float * result, const float
++
++ #include <immintrin.h>
++
++-static inline void volk_32f_x2_dot_prod_32f_a_avx( float* result, const float* input, const float* taps, unsigned int num_points) {
+++static inline void volk_32f_x2_dot_prod_32f_a_avx(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
++
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float dotProduct = 0;
++- const float* aPtr = input;
++- const float* bPtr = taps;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- __m256 a0Val, a1Val;
++- __m256 b0Val, b1Val;
++- __m256 c0Val, c1Val;
+++ float dotProduct = 0;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
++
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 a0Val, a1Val;
+++ __m256 b0Val, b1Val;
+++ __m256 c0Val, c1Val;
++
++- for(;number < sixteenthPoints; number++){
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
++
++- a0Val = _mm256_load_ps(aPtr);
++- a1Val = _mm256_load_ps(aPtr+8);
++- b0Val = _mm256_load_ps(bPtr);
++- b1Val = _mm256_load_ps(bPtr+8);
+++ for (; number < sixteenthPoints; number++) {
++
++- c0Val = _mm256_mul_ps(a0Val, b0Val);
++- c1Val = _mm256_mul_ps(a1Val, b1Val);
+++ a0Val = _mm256_load_ps(aPtr);
+++ a1Val = _mm256_load_ps(aPtr + 8);
+++ b0Val = _mm256_load_ps(bPtr);
+++ b1Val = _mm256_load_ps(bPtr + 8);
++
++- dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
+++ c0Val = _mm256_mul_ps(a0Val, b0Val);
+++ c1Val = _mm256_mul_ps(a1Val, b1Val);
++
++- aPtr += 16;
++- bPtr += 16;
++- }
+++ dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
++
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ aPtr += 16;
+++ bPtr += 16;
+++ }
++
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++
++- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++
++- dotProduct = dotProductVector[0];
++- dotProduct += dotProductVector[1];
++- dotProduct += dotProductVector[2];
++- dotProduct += dotProductVector[3];
++- dotProduct += dotProductVector[4];
++- dotProduct += dotProductVector[5];
++- dotProduct += dotProductVector[6];
++- dotProduct += dotProductVector[7];
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
++
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
+++ dotProduct = dotProductVector[0];
+++ dotProduct += dotProductVector[1];
+++ dotProduct += dotProductVector[2];
+++ dotProduct += dotProductVector[3];
+++ dotProduct += dotProductVector[4];
+++ dotProduct += dotProductVector[5];
+++ dotProduct += dotProductVector[6];
+++ dotProduct += dotProductVector[7];
++
++- *result = dotProduct;
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
+++ *result = dotProduct;
++ }
++ #endif /*LV_HAVE_AVX*/
++
++
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++ #include <immintrin.h>
++-static inline void volk_32f_x2_dot_prod_32f_a_avx2_fma(float * result, const float * input, const float* taps, unsigned int num_points){
++- unsigned int number;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* aPtr = input;
++- const float* bPtr = taps;
+++static inline void volk_32f_x2_dot_prod_32f_a_avx2_fma(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++ unsigned int number;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- __m256 dotProdVal = _mm256_setzero_ps();
++- __m256 aVal1, bVal1;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
++
++- for (number = 0; number < eighthPoints; number++ ) {
+++ __m256 dotProdVal = _mm256_setzero_ps();
+++ __m256 aVal1, bVal1;
++
++- aVal1 = _mm256_load_ps(aPtr);
++- bVal1 = _mm256_load_ps(bPtr);
++- aPtr += 8;
++- bPtr += 8;
+++ for (number = 0; number < eighthPoints; number++) {
++
++- dotProdVal = _mm256_fmadd_ps(aVal1, bVal1, dotProdVal);
++- }
+++ aVal1 = _mm256_load_ps(aPtr);
+++ bVal1 = _mm256_load_ps(bPtr);
+++ aPtr += 8;
+++ bPtr += 8;
++
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++- _mm256_store_ps(dotProductVector, dotProdVal); // Store the results back into the dot product vector
++- _mm256_zeroupper();
+++ dotProdVal = _mm256_fmadd_ps(aVal1, bVal1, dotProdVal);
+++ }
++
++- float dotProduct =
++- dotProductVector[0] + dotProductVector[1] +
++- dotProductVector[2] + dotProductVector[3] +
++- dotProductVector[4] + dotProductVector[5] +
++- dotProductVector[6] + dotProductVector[7];
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal); // Store the results back into the dot product vector
+++ _mm256_zeroupper();
++
++- for(number = eighthPoints * 8; number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
+++ float dotProduct = dotProductVector[0] + dotProductVector[1] + dotProductVector[2] +
+++ dotProductVector[3] + dotProductVector[4] + dotProductVector[5] +
+++ dotProductVector[6] + dotProductVector[7];
++
++- *result = dotProduct;
+++ for (number = eighthPoints * 8; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
+++ *result = dotProduct;
++ }
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA */
++
++ #if LV_HAVE_AVX512F
++ #include <immintrin.h>
++-static inline void volk_32f_x2_dot_prod_32f_a_avx512f(float * result, const float * input, const float* taps, unsigned int num_points){
++- unsigned int number;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- const float* aPtr = input;
++- const float* bPtr = taps;
+++static inline void volk_32f_x2_dot_prod_32f_a_avx512f(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++ unsigned int number;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- __m512 dotProdVal = _mm512_setzero_ps();
++- __m512 aVal1, bVal1;
+++ const float* aPtr = input;
+++ const float* bPtr = taps;
++
++- for (number = 0; number < sixteenthPoints; number++ ) {
+++ __m512 dotProdVal = _mm512_setzero_ps();
+++ __m512 aVal1, bVal1;
++
++- aVal1 = _mm512_load_ps(aPtr);
++- bVal1 = _mm512_load_ps(bPtr);
++- aPtr += 16;
++- bPtr += 16;
+++ for (number = 0; number < sixteenthPoints; number++) {
++
++- dotProdVal = _mm512_fmadd_ps(aVal1, bVal1, dotProdVal);
++- }
+++ aVal1 = _mm512_load_ps(aPtr);
+++ bVal1 = _mm512_load_ps(bPtr);
+++ aPtr += 16;
+++ bPtr += 16;
++
++- __VOLK_ATTR_ALIGNED(64) float dotProductVector[16];
++- _mm512_store_ps(dotProductVector, dotProdVal); // Store the results back into the dot product vector
+++ dotProdVal = _mm512_fmadd_ps(aVal1, bVal1, dotProdVal);
+++ }
++
++- float dotProduct =
++- dotProductVector[0] + dotProductVector[1] +
++- dotProductVector[2] + dotProductVector[3] +
++- dotProductVector[4] + dotProductVector[5] +
++- dotProductVector[6] + dotProductVector[7] +
++- dotProductVector[8] + dotProductVector[9] +
++- dotProductVector[10] + dotProductVector[11] +
++- dotProductVector[12] + dotProductVector[13] +
++- dotProductVector[14] + dotProductVector[15];
+++ __VOLK_ATTR_ALIGNED(64) float dotProductVector[16];
+++ _mm512_store_ps(dotProductVector,
+++ dotProdVal); // Store the results back into the dot product vector
++
++- for(number = sixteenthPoints * 16; number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
++- }
+++ float dotProduct = dotProductVector[0] + dotProductVector[1] + dotProductVector[2] +
+++ dotProductVector[3] + dotProductVector[4] + dotProductVector[5] +
+++ dotProductVector[6] + dotProductVector[7] + dotProductVector[8] +
+++ dotProductVector[9] + dotProductVector[10] + dotProductVector[11] +
+++ dotProductVector[12] + dotProductVector[13] +
+++ dotProductVector[14] + dotProductVector[15];
++
++- *result = dotProduct;
+++ for (number = sixteenthPoints * 16; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
+++ }
++
+++ *result = dotProduct;
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_32f_x2_dot_prod_32f_neonopts(float * result, const float * input, const float * taps, unsigned int num_points) {
+++static inline void volk_32f_x2_dot_prod_32f_neonopts(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
++
++ unsigned int quarter_points = num_points / 16;
++ float dotProduct = 0;
++ const float* aPtr = input;
++- const float* bPtr= taps;
+++ const float* bPtr = taps;
++ unsigned int number = 0;
++
++ float32x4x4_t a_val, b_val, accumulator0;
++@@ -838,7 +906,7 @@ static inline void volk_32f_x2_dot_prod_32f_neonopts(float * result, const float
++ accumulator0.val[3] = vdupq_n_f32(0);
++ // factor of 4 loop unroll with independent accumulators
++ // uses 12 out of 16 neon q registers
++- for( number = 0; number < quarter_points; ++number) {
+++ for (number = 0; number < quarter_points; ++number) {
++ a_val = vld4q_f32(aPtr);
++ b_val = vld4q_f32(bPtr);
++ accumulator0.val[0] = vmlaq_f32(accumulator0.val[0], a_val.val[0], b_val.val[0]);
++@@ -855,8 +923,8 @@ static inline void volk_32f_x2_dot_prod_32f_neonopts(float * result, const float
++ vst1q_f32(accumulator, accumulator0.val[0]);
++ dotProduct = accumulator[0] + accumulator[1] + accumulator[2] + accumulator[3];
++
++- for(number = quarter_points*16; number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
+++ for (number = quarter_points * 16; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
++ }
++
++ *result = dotProduct;
++@@ -865,26 +933,30 @@ static inline void volk_32f_x2_dot_prod_32f_neonopts(float * result, const float
++ #endif
++
++
++-
++-
++ #ifdef LV_HAVE_NEON
++-static inline void volk_32f_x2_dot_prod_32f_neon(float * result, const float * input, const float * taps, unsigned int num_points) {
+++static inline void volk_32f_x2_dot_prod_32f_neon(float* result,
+++ const float* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
++
++ unsigned int quarter_points = num_points / 8;
++ float dotProduct = 0;
++ const float* aPtr = input;
++- const float* bPtr= taps;
+++ const float* bPtr = taps;
++ unsigned int number = 0;
++
++ float32x4x2_t a_val, b_val, accumulator_val;
++ accumulator_val.val[0] = vdupq_n_f32(0);
++ accumulator_val.val[1] = vdupq_n_f32(0);
++ // factor of 2 loop unroll with independent accumulators
++- for( number = 0; number < quarter_points; ++number) {
+++ for (number = 0; number < quarter_points; ++number) {
++ a_val = vld2q_f32(aPtr);
++ b_val = vld2q_f32(bPtr);
++- accumulator_val.val[0] = vmlaq_f32(accumulator_val.val[0], a_val.val[0], b_val.val[0]);
++- accumulator_val.val[1] = vmlaq_f32(accumulator_val.val[1], a_val.val[1], b_val.val[1]);
+++ accumulator_val.val[0] =
+++ vmlaq_f32(accumulator_val.val[0], a_val.val[0], b_val.val[0]);
+++ accumulator_val.val[1] =
+++ vmlaq_f32(accumulator_val.val[1], a_val.val[1], b_val.val[1]);
++ aPtr += 8;
++ bPtr += 8;
++ }
++@@ -893,8 +965,8 @@ static inline void volk_32f_x2_dot_prod_32f_neon(float * result, const float * i
++ vst1q_f32(accumulator, accumulator_val.val[0]);
++ dotProduct = accumulator[0] + accumulator[1] + accumulator[2] + accumulator[3];
++
++- for(number = quarter_points*8; number < num_points; number++){
++- dotProduct += ((*aPtr++) * (*bPtr++));
+++ for (number = quarter_points * 8; number < num_points; number++) {
+++ dotProduct += ((*aPtr++) * (*bPtr++));
++ }
++
++ *result = dotProduct;
++@@ -903,11 +975,17 @@ static inline void volk_32f_x2_dot_prod_32f_neon(float * result, const float * i
++ #endif /* LV_HAVE_NEON */
++
++ #ifdef LV_HAVE_NEONV7
++-extern void volk_32f_x2_dot_prod_32f_a_neonasm(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
+++extern void volk_32f_x2_dot_prod_32f_a_neonasm(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points);
++ #endif /* LV_HAVE_NEONV7 */
++
++ #ifdef LV_HAVE_NEONV7
++-extern void volk_32f_x2_dot_prod_32f_a_neonasm_opts(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
+++extern void volk_32f_x2_dot_prod_32f_a_neonasm_opts(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points);
++ #endif /* LV_HAVE_NEONV7 */
++
++ #endif /*INCLUDED_volk_32f_x2_dot_prod_32f_a_H*/
++diff --git a/kernels/volk/volk_32f_x2_fm_detectpuppet_32f.h b/kernels/volk/volk_32f_x2_fm_detectpuppet_32f.h
++index e1da185..3a3caca 100644
++--- a/kernels/volk/volk_32f_x2_fm_detectpuppet_32f.h
+++++ b/kernels/volk/volk_32f_x2_fm_detectpuppet_32f.h
++@@ -28,32 +28,44 @@
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32f_x2_fm_detectpuppet_32f_a_avx(float* outputVector, const float* inputVector, float* saveValue, unsigned int num_points)
+++static inline void volk_32f_x2_fm_detectpuppet_32f_a_avx(float* outputVector,
+++ const float* inputVector,
+++ float* saveValue,
+++ unsigned int num_points)
++ {
++- const float bound = 1.0f;
+++ const float bound = 1.0f;
++
++- volk_32f_s32f_32f_fm_detect_32f_a_avx(outputVector, inputVector, bound, saveValue, num_points);
+++ volk_32f_s32f_32f_fm_detect_32f_a_avx(
+++ outputVector, inputVector, bound, saveValue, num_points);
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void volk_32f_x2_fm_detectpuppet_32f_a_sse(float* outputVector, const float* inputVector, float* saveValue, unsigned int num_points)
+++static inline void volk_32f_x2_fm_detectpuppet_32f_a_sse(float* outputVector,
+++ const float* inputVector,
+++ float* saveValue,
+++ unsigned int num_points)
++ {
++- const float bound = 1.0f;
+++ const float bound = 1.0f;
++
++- volk_32f_s32f_32f_fm_detect_32f_a_sse(outputVector, inputVector, bound, saveValue, num_points);
+++ volk_32f_s32f_32f_fm_detect_32f_a_sse(
+++ outputVector, inputVector, bound, saveValue, num_points);
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32f_x2_fm_detectpuppet_32f_generic(float* outputVector, const float* inputVector, float* saveValue, unsigned int num_points)
+++static inline void volk_32f_x2_fm_detectpuppet_32f_generic(float* outputVector,
+++ const float* inputVector,
+++ float* saveValue,
+++ unsigned int num_points)
++ {
++- const float bound = 1.0f;
+++ const float bound = 1.0f;
++
++- volk_32f_s32f_32f_fm_detect_32f_generic(outputVector, inputVector, bound, saveValue, num_points);
+++ volk_32f_s32f_32f_fm_detect_32f_generic(
+++ outputVector, inputVector, bound, saveValue, num_points);
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -69,11 +81,15 @@ static inline void volk_32f_x2_fm_detectpuppet_32f_generic(float* outputVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32f_x2_fm_detectpuppet_32f_u_avx(float* outputVector, const float* inputVector, float* saveValue, unsigned int num_points)
+++static inline void volk_32f_x2_fm_detectpuppet_32f_u_avx(float* outputVector,
+++ const float* inputVector,
+++ float* saveValue,
+++ unsigned int num_points)
++ {
++- const float bound = 1.0f;
+++ const float bound = 1.0f;
++
++- volk_32f_s32f_32f_fm_detect_32f_u_avx(outputVector, inputVector, bound, saveValue, num_points);
+++ volk_32f_s32f_32f_fm_detect_32f_u_avx(
+++ outputVector, inputVector, bound, saveValue, num_points);
++ }
++ #endif /* LV_HAVE_AVX */
++ #endif /* INCLUDED_volk_32f_x2_fm_detectpuppet_32f_u_H */
++diff --git a/kernels/volk/volk_32f_x2_interleave_32fc.h b/kernels/volk/volk_32f_x2_interleave_32fc.h
++index ef8ada2..d0cc6dd 100644
++--- a/kernels/volk/volk_32f_x2_interleave_32fc.h
+++++ b/kernels/volk/volk_32f_x2_interleave_32fc.h
++@@ -33,8 +33,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_x2_interleave_32fc(lv_32fc_t* complexVector, const float* iBuffer, const float* qBuffer, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_x2_interleave_32fc(lv_32fc_t* complexVector, const float* iBuffer, const
+++ * float* qBuffer, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li iBuffer: Input vector of samples for the real part.
++@@ -79,44 +79,45 @@
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_interleave_32fc_a_avx(lv_32fc_t* complexVector, const float* iBuffer,
++- const float* qBuffer, unsigned int num_points)
+++static inline void volk_32f_x2_interleave_32fc_a_avx(lv_32fc_t* complexVector,
+++ const float* iBuffer,
+++ const float* qBuffer,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- float* complexVectorPtr = (float*)complexVector;
++- const float* iBufferPtr = iBuffer;
++- const float* qBufferPtr = qBuffer;
++-
++- const uint64_t eighthPoints = num_points / 8;
++-
++- __m256 iValue, qValue, cplxValue1, cplxValue2, cplxValue;
++- for(;number < eighthPoints; number++){
++- iValue = _mm256_load_ps(iBufferPtr);
++- qValue = _mm256_load_ps(qBufferPtr);
++-
++- // Interleaves the lower two values in the i and q variables into one buffer
++- cplxValue1 = _mm256_unpacklo_ps(iValue, qValue);
++- // Interleaves the upper two values in the i and q variables into one buffer
++- cplxValue2 = _mm256_unpackhi_ps(iValue, qValue);
++-
++- cplxValue = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
++- _mm256_store_ps(complexVectorPtr, cplxValue);
++- complexVectorPtr += 8;
++-
++- cplxValue = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
++- _mm256_store_ps(complexVectorPtr, cplxValue);
++- complexVectorPtr += 8;
++-
++- iBufferPtr += 8;
++- qBufferPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- *complexVectorPtr++ = *iBufferPtr++;
++- *complexVectorPtr++ = *qBufferPtr++;
++- }
+++ unsigned int number = 0;
+++ float* complexVectorPtr = (float*)complexVector;
+++ const float* iBufferPtr = iBuffer;
+++ const float* qBufferPtr = qBuffer;
+++
+++ const uint64_t eighthPoints = num_points / 8;
+++
+++ __m256 iValue, qValue, cplxValue1, cplxValue2, cplxValue;
+++ for (; number < eighthPoints; number++) {
+++ iValue = _mm256_load_ps(iBufferPtr);
+++ qValue = _mm256_load_ps(qBufferPtr);
+++
+++ // Interleaves the lower two values in the i and q variables into one buffer
+++ cplxValue1 = _mm256_unpacklo_ps(iValue, qValue);
+++ // Interleaves the upper two values in the i and q variables into one buffer
+++ cplxValue2 = _mm256_unpackhi_ps(iValue, qValue);
+++
+++ cplxValue = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
+++ _mm256_store_ps(complexVectorPtr, cplxValue);
+++ complexVectorPtr += 8;
+++
+++ cplxValue = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
+++ _mm256_store_ps(complexVectorPtr, cplxValue);
+++ complexVectorPtr += 8;
+++
+++ iBufferPtr += 8;
+++ qBufferPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *complexVectorPtr++ = *iBufferPtr++;
+++ *complexVectorPtr++ = *qBufferPtr++;
+++ }
++ }
++
++ #endif /* LV_HAV_AVX */
++@@ -124,41 +125,42 @@ volk_32f_x2_interleave_32fc_a_avx(lv_32fc_t* complexVector, const float* iBuffer
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_x2_interleave_32fc_a_sse(lv_32fc_t* complexVector, const float* iBuffer,
++- const float* qBuffer, unsigned int num_points)
+++static inline void volk_32f_x2_interleave_32fc_a_sse(lv_32fc_t* complexVector,
+++ const float* iBuffer,
+++ const float* qBuffer,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- float* complexVectorPtr = (float*)complexVector;
++- const float* iBufferPtr = iBuffer;
++- const float* qBufferPtr = qBuffer;
++-
++- const uint64_t quarterPoints = num_points / 4;
++-
++- __m128 iValue, qValue, cplxValue;
++- for(;number < quarterPoints; number++){
++- iValue = _mm_load_ps(iBufferPtr);
++- qValue = _mm_load_ps(qBufferPtr);
++-
++- // Interleaves the lower two values in the i and q variables into one buffer
++- cplxValue = _mm_unpacklo_ps(iValue, qValue);
++- _mm_store_ps(complexVectorPtr, cplxValue);
++- complexVectorPtr += 4;
++-
++- // Interleaves the upper two values in the i and q variables into one buffer
++- cplxValue = _mm_unpackhi_ps(iValue, qValue);
++- _mm_store_ps(complexVectorPtr, cplxValue);
++- complexVectorPtr += 4;
++-
++- iBufferPtr += 4;
++- qBufferPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- *complexVectorPtr++ = *iBufferPtr++;
++- *complexVectorPtr++ = *qBufferPtr++;
++- }
+++ unsigned int number = 0;
+++ float* complexVectorPtr = (float*)complexVector;
+++ const float* iBufferPtr = iBuffer;
+++ const float* qBufferPtr = qBuffer;
+++
+++ const uint64_t quarterPoints = num_points / 4;
+++
+++ __m128 iValue, qValue, cplxValue;
+++ for (; number < quarterPoints; number++) {
+++ iValue = _mm_load_ps(iBufferPtr);
+++ qValue = _mm_load_ps(qBufferPtr);
+++
+++ // Interleaves the lower two values in the i and q variables into one buffer
+++ cplxValue = _mm_unpacklo_ps(iValue, qValue);
+++ _mm_store_ps(complexVectorPtr, cplxValue);
+++ complexVectorPtr += 4;
+++
+++ // Interleaves the upper two values in the i and q variables into one buffer
+++ cplxValue = _mm_unpackhi_ps(iValue, qValue);
+++ _mm_store_ps(complexVectorPtr, cplxValue);
+++ complexVectorPtr += 4;
+++
+++ iBufferPtr += 4;
+++ qBufferPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *complexVectorPtr++ = *iBufferPtr++;
+++ *complexVectorPtr++ = *qBufferPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -166,52 +168,53 @@ volk_32f_x2_interleave_32fc_a_sse(lv_32fc_t* complexVector, const float* iBuffer
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32f_x2_interleave_32fc_neon(lv_32fc_t* complexVector, const float* iBuffer,
++- const float* qBuffer, unsigned int num_points)
+++static inline void volk_32f_x2_interleave_32fc_neon(lv_32fc_t* complexVector,
+++ const float* iBuffer,
+++ const float* qBuffer,
+++ unsigned int num_points)
++ {
++- unsigned int quarter_points = num_points / 4;
++- unsigned int number;
++- float* complexVectorPtr = (float*) complexVector;
++-
++- float32x4x2_t complex_vec;
++- for(number=0; number < quarter_points; ++number) {
++- complex_vec.val[0] = vld1q_f32(iBuffer);
++- complex_vec.val[1] = vld1q_f32(qBuffer);
++- vst2q_f32(complexVectorPtr, complex_vec);
++- iBuffer += 4;
++- qBuffer += 4;
++- complexVectorPtr += 8;
++- }
++-
++- for(number=quarter_points * 4; number < num_points; ++number) {
++- *complexVectorPtr++ = *iBuffer++;
++- *complexVectorPtr++ = *qBuffer++;
++- }
+++ unsigned int quarter_points = num_points / 4;
+++ unsigned int number;
+++ float* complexVectorPtr = (float*)complexVector;
+++
+++ float32x4x2_t complex_vec;
+++ for (number = 0; number < quarter_points; ++number) {
+++ complex_vec.val[0] = vld1q_f32(iBuffer);
+++ complex_vec.val[1] = vld1q_f32(qBuffer);
+++ vst2q_f32(complexVectorPtr, complex_vec);
+++ iBuffer += 4;
+++ qBuffer += 4;
+++ complexVectorPtr += 8;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; ++number) {
+++ *complexVectorPtr++ = *iBuffer++;
+++ *complexVectorPtr++ = *qBuffer++;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_x2_interleave_32fc_generic(lv_32fc_t* complexVector, const float* iBuffer,
++- const float* qBuffer, unsigned int num_points)
+++static inline void volk_32f_x2_interleave_32fc_generic(lv_32fc_t* complexVector,
+++ const float* iBuffer,
+++ const float* qBuffer,
+++ unsigned int num_points)
++ {
++- float* complexVectorPtr = (float*)complexVector;
++- const float* iBufferPtr = iBuffer;
++- const float* qBufferPtr = qBuffer;
++- unsigned int number;
++-
++- for(number = 0; number < num_points; number++){
++- *complexVectorPtr++ = *iBufferPtr++;
++- *complexVectorPtr++ = *qBufferPtr++;
++- }
+++ float* complexVectorPtr = (float*)complexVector;
+++ const float* iBufferPtr = iBuffer;
+++ const float* qBufferPtr = qBuffer;
+++ unsigned int number;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *complexVectorPtr++ = *iBufferPtr++;
+++ *complexVectorPtr++ = *qBufferPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++ #endif /* INCLUDED_volk_32f_x2_interleave_32fc_a_H */
++
++ #ifndef INCLUDED_volk_32f_x2_interleave_32fc_u_H
++@@ -223,44 +226,45 @@ volk_32f_x2_interleave_32fc_generic(lv_32fc_t* complexVector, const float* iBuff
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_interleave_32fc_u_avx(lv_32fc_t* complexVector, const float* iBuffer,
++- const float* qBuffer, unsigned int num_points)
+++static inline void volk_32f_x2_interleave_32fc_u_avx(lv_32fc_t* complexVector,
+++ const float* iBuffer,
+++ const float* qBuffer,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- float* complexVectorPtr = (float*)complexVector;
++- const float* iBufferPtr = iBuffer;
++- const float* qBufferPtr = qBuffer;
++-
++- const uint64_t eighthPoints = num_points / 8;
++-
++- __m256 iValue, qValue, cplxValue1, cplxValue2, cplxValue;
++- for(;number < eighthPoints; number++){
++- iValue = _mm256_loadu_ps(iBufferPtr);
++- qValue = _mm256_loadu_ps(qBufferPtr);
++-
++- // Interleaves the lower two values in the i and q variables into one buffer
++- cplxValue1 = _mm256_unpacklo_ps(iValue, qValue);
++- // Interleaves the upper two values in the i and q variables into one buffer
++- cplxValue2 = _mm256_unpackhi_ps(iValue, qValue);
++-
++- cplxValue = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
++- _mm256_storeu_ps(complexVectorPtr, cplxValue);
++- complexVectorPtr += 8;
++-
++- cplxValue = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
++- _mm256_storeu_ps(complexVectorPtr, cplxValue);
++- complexVectorPtr += 8;
++-
++- iBufferPtr += 8;
++- qBufferPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- *complexVectorPtr++ = *iBufferPtr++;
++- *complexVectorPtr++ = *qBufferPtr++;
++- }
+++ unsigned int number = 0;
+++ float* complexVectorPtr = (float*)complexVector;
+++ const float* iBufferPtr = iBuffer;
+++ const float* qBufferPtr = qBuffer;
+++
+++ const uint64_t eighthPoints = num_points / 8;
+++
+++ __m256 iValue, qValue, cplxValue1, cplxValue2, cplxValue;
+++ for (; number < eighthPoints; number++) {
+++ iValue = _mm256_loadu_ps(iBufferPtr);
+++ qValue = _mm256_loadu_ps(qBufferPtr);
+++
+++ // Interleaves the lower two values in the i and q variables into one buffer
+++ cplxValue1 = _mm256_unpacklo_ps(iValue, qValue);
+++ // Interleaves the upper two values in the i and q variables into one buffer
+++ cplxValue2 = _mm256_unpackhi_ps(iValue, qValue);
+++
+++ cplxValue = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
+++ _mm256_storeu_ps(complexVectorPtr, cplxValue);
+++ complexVectorPtr += 8;
+++
+++ cplxValue = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
+++ _mm256_storeu_ps(complexVectorPtr, cplxValue);
+++ complexVectorPtr += 8;
+++
+++ iBufferPtr += 8;
+++ qBufferPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *complexVectorPtr++ = *iBufferPtr++;
+++ *complexVectorPtr++ = *qBufferPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++diff --git a/kernels/volk/volk_32f_x2_max_32f.h b/kernels/volk/volk_32f_x2_max_32f.h
++index 82086a6..c7eb67f 100644
++--- a/kernels/volk/volk_32f_x2_max_32f.h
+++++ b/kernels/volk/volk_32f_x2_max_32f.h
++@@ -32,8 +32,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_x2_max_32f(float* cVector, const float* aVector, const float* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_x2_max_32f(float* cVector, const float* aVector, const float* bVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: First input vector.
++@@ -77,176 +77,183 @@
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_max_32f_a_avx512f(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_max_32f_a_avx512f(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m512 aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
++- aVal = _mm512_load_ps(aPtr);
++- bVal = _mm512_load_ps(bPtr);
+++ __m512 aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
+++ aVal = _mm512_load_ps(aPtr);
+++ bVal = _mm512_load_ps(bPtr);
++
++- cVal = _mm512_max_ps(aVal, bVal);
+++ cVal = _mm512_max_ps(aVal, bVal);
++
++- _mm512_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm512_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a > b ? a : b);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a > b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_x2_max_32f_a_sse(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_max_32f_a_sse(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m128 aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
++- aVal = _mm_load_ps(aPtr);
++- bVal = _mm_load_ps(bPtr);
+++ __m128 aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
+++ bVal = _mm_load_ps(bPtr);
++
++- cVal = _mm_max_ps(aVal, bVal);
+++ cVal = _mm_max_ps(aVal, bVal);
++
++- _mm_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a > b ? a : b);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a > b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_max_32f_a_avx(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_max_32f_a_avx(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m256 aVal, bVal, cVal;
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- bVal = _mm256_load_ps(bPtr);
+++ __m256 aVal, bVal, cVal;
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ bVal = _mm256_load_ps(bPtr);
++
++- cVal = _mm256_max_ps(aVal, bVal);
+++ cVal = _mm256_max_ps(aVal, bVal);
++
++- _mm256_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a > b ? a : b);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a > b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32f_x2_max_32f_neon(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_max_32f_neon(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int quarter_points = num_points / 4;
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
++- unsigned int number = 0;
++-
++- float32x4_t a_vec, b_vec, c_vec;
++- for(number = 0; number < quarter_points; number++){
++- a_vec = vld1q_f32(aPtr);
++- b_vec = vld1q_f32(bPtr);
++- c_vec = vmaxq_f32(a_vec, b_vec);
++- vst1q_f32(cPtr, c_vec);
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
++-
++- for(number = quarter_points*4; number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a > b ? a : b);
++- }
+++ unsigned int quarter_points = num_points / 4;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ float32x4_t a_vec, b_vec, c_vec;
+++ for (number = 0; number < quarter_points; number++) {
+++ a_vec = vld1q_f32(aPtr);
+++ b_vec = vld1q_f32(bPtr);
+++ c_vec = vmaxq_f32(a_vec, b_vec);
+++ vst1q_f32(cPtr, c_vec);
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a > b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_x2_max_32f_generic(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_max_32f_generic(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a > b ? a : b);
++- }
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a > b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_ORC
++-extern void
++-volk_32f_x2_max_32f_a_orc_impl(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points);
++-
++-static inline void
++-volk_32f_x2_max_32f_u_orc(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++extern void volk_32f_x2_max_32f_a_orc_impl(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points);
+++
+++static inline void volk_32f_x2_max_32f_u_orc(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- volk_32f_x2_max_32f_a_orc_impl(cVector, aVector, bVector, num_points);
+++ volk_32f_x2_max_32f_a_orc_impl(cVector, aVector, bVector, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++@@ -263,74 +270,76 @@ volk_32f_x2_max_32f_u_orc(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_max_32f_u_avx512f(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_max_32f_u_avx512f(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m512 aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
++- aVal = _mm512_loadu_ps(aPtr);
++- bVal = _mm512_loadu_ps(bPtr);
+++ __m512 aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
+++ aVal = _mm512_loadu_ps(aPtr);
+++ bVal = _mm512_loadu_ps(bPtr);
++
++- cVal = _mm512_max_ps(aVal, bVal);
+++ cVal = _mm512_max_ps(aVal, bVal);
++
++- _mm512_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm512_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a > b ? a : b);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a > b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_max_32f_u_avx(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_max_32f_u_avx(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m256 aVal, bVal, cVal;
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- bVal = _mm256_loadu_ps(bPtr);
+++ __m256 aVal, bVal, cVal;
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ bVal = _mm256_loadu_ps(bPtr);
++
++- cVal = _mm256_max_ps(aVal, bVal);
+++ cVal = _mm256_max_ps(aVal, bVal);
++
++- _mm256_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a > b ? a : b);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a > b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++diff --git a/kernels/volk/volk_32f_x2_min_32f.h b/kernels/volk/volk_32f_x2_min_32f.h
++index 454eb76..aecd11a 100644
++--- a/kernels/volk/volk_32f_x2_min_32f.h
+++++ b/kernels/volk/volk_32f_x2_min_32f.h
++@@ -32,8 +32,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_x2_min_32f(float* cVector, const float* aVector, const float* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_x2_min_32f(float* cVector, const float* aVector, const float* bVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: First input vector.
++@@ -77,37 +77,38 @@
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_x2_min_32f_a_sse(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_min_32f_a_sse(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m128 aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
++- aVal = _mm_load_ps(aPtr);
++- bVal = _mm_load_ps(bPtr);
+++ __m128 aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
+++ bVal = _mm_load_ps(bPtr);
++
++- cVal = _mm_min_ps(aVal, bVal);
+++ cVal = _mm_min_ps(aVal, bVal);
++
++- _mm_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a < b ? a : b);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a < b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -115,143 +116,149 @@ volk_32f_x2_min_32f_a_sse(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32f_x2_min_32f_neon(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_min_32f_neon(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
++- unsigned int number = 0;
++- unsigned int quarter_points = num_points / 4;
++-
++- float32x4_t a_vec, b_vec, c_vec;
++- for(number = 0; number < quarter_points; number++){
++- a_vec = vld1q_f32(aPtr);
++- b_vec = vld1q_f32(bPtr);
++-
++- c_vec = vminq_f32(a_vec, b_vec);
++-
++- vst1q_f32(cPtr, c_vec);
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
++-
++- for(number = quarter_points*4; number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a < b ? a : b);
++- }
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++ unsigned int quarter_points = num_points / 4;
+++
+++ float32x4_t a_vec, b_vec, c_vec;
+++ for (number = 0; number < quarter_points; number++) {
+++ a_vec = vld1q_f32(aPtr);
+++ b_vec = vld1q_f32(bPtr);
+++
+++ c_vec = vminq_f32(a_vec, b_vec);
+++
+++ vst1q_f32(cPtr, c_vec);
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a < b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_x2_min_32f_generic(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_min_32f_generic(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a < b ? a : b);
++- }
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a < b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++ #ifdef LV_HAVE_ORC
++
++-extern void
++-volk_32f_x2_min_32f_a_orc_impl(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points);
+++extern void volk_32f_x2_min_32f_a_orc_impl(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points);
++
++-static inline void
++-volk_32f_x2_min_32f_u_orc(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_min_32f_u_orc(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- volk_32f_x2_min_32f_a_orc_impl(cVector, aVector, bVector, num_points);
+++ volk_32f_x2_min_32f_a_orc_impl(cVector, aVector, bVector, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_min_32f_a_avx(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_min_32f_a_avx(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m256 aVal, bVal, cVal;
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_load_ps(aPtr);
++- bVal = _mm256_load_ps(bPtr);
+++ __m256 aVal, bVal, cVal;
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_load_ps(aPtr);
+++ bVal = _mm256_load_ps(bPtr);
++
++- cVal = _mm256_min_ps(aVal, bVal);
+++ cVal = _mm256_min_ps(aVal, bVal);
++
++- _mm256_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a < b ? a : b);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a < b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_min_32f_a_avx512f(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_min_32f_a_avx512f(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m512 aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
++- aVal = _mm512_load_ps(aPtr);
++- bVal = _mm512_load_ps(bPtr);
+++ __m512 aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
+++ aVal = _mm512_load_ps(aPtr);
+++ bVal = _mm512_load_ps(bPtr);
++
++- cVal = _mm512_min_ps(aVal, bVal);
+++ cVal = _mm512_min_ps(aVal, bVal);
++
++- _mm512_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm512_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a < b ? a : b);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a < b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++@@ -267,74 +274,76 @@ volk_32f_x2_min_32f_a_avx512f(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_min_32f_u_avx512f(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_min_32f_u_avx512f(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m512 aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
++- aVal = _mm512_loadu_ps(aPtr);
++- bVal = _mm512_loadu_ps(bPtr);
+++ __m512 aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
+++ aVal = _mm512_loadu_ps(aPtr);
+++ bVal = _mm512_loadu_ps(bPtr);
++
++- cVal = _mm512_min_ps(aVal, bVal);
+++ cVal = _mm512_min_ps(aVal, bVal);
++
++- _mm512_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm512_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a < b ? a : b);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a < b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_min_32f_u_avx(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_min_32f_u_avx(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m256 aVal, bVal, cVal;
++- for(;number < eighthPoints; number++){
++- aVal = _mm256_loadu_ps(aPtr);
++- bVal = _mm256_loadu_ps(bPtr);
+++ __m256 aVal, bVal, cVal;
+++ for (; number < eighthPoints; number++) {
+++ aVal = _mm256_loadu_ps(aPtr);
+++ bVal = _mm256_loadu_ps(bPtr);
++
++- cVal = _mm256_min_ps(aVal, bVal);
+++ cVal = _mm256_min_ps(aVal, bVal);
++
++- _mm256_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- const float a = *aPtr++;
++- const float b = *bPtr++;
++- *cPtr++ = ( a < b ? a : b);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ const float a = *aPtr++;
+++ const float b = *bPtr++;
+++ *cPtr++ = (a < b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++diff --git a/kernels/volk/volk_32f_x2_multiply_32f.h b/kernels/volk/volk_32f_x2_multiply_32f.h
++index deb9ae3..eebba18 100644
++--- a/kernels/volk/volk_32f_x2_multiply_32f.h
+++++ b/kernels/volk/volk_32f_x2_multiply_32f.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_x2_multiply_32f(float* cVector, const float* aVector, const float* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_x2_multiply_32f(float* cVector, const float* aVector, const float*
+++ * bVector, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: First input vector.
++@@ -77,126 +77,130 @@
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_x2_multiply_32f_u_sse(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_multiply_32f_u_sse(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m128 aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
+++ __m128 aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm_loadu_ps(aPtr);
++- bVal = _mm_loadu_ps(bPtr);
+++ aVal = _mm_loadu_ps(aPtr);
+++ bVal = _mm_loadu_ps(bPtr);
++
++- cVal = _mm_mul_ps(aVal, bVal);
+++ cVal = _mm_mul_ps(aVal, bVal);
++
++- _mm_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_multiply_32f_u_avx512f(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_multiply_32f_u_avx512f(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m512 aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
+++ __m512 aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
++
++- aVal = _mm512_loadu_ps(aPtr);
++- bVal = _mm512_loadu_ps(bPtr);
+++ aVal = _mm512_loadu_ps(aPtr);
+++ bVal = _mm512_loadu_ps(bPtr);
++
++- cVal = _mm512_mul_ps(aVal, bVal);
+++ cVal = _mm512_mul_ps(aVal, bVal);
++
++- _mm512_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm512_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_multiply_32f_u_avx(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_multiply_32f_u_avx(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m256 aVal, bVal, cVal;
++- for(;number < eighthPoints; number++){
+++ __m256 aVal, bVal, cVal;
+++ for (; number < eighthPoints; number++) {
++
++- aVal = _mm256_loadu_ps(aPtr);
++- bVal = _mm256_loadu_ps(bPtr);
+++ aVal = _mm256_loadu_ps(aPtr);
+++ bVal = _mm256_loadu_ps(bPtr);
++
++- cVal = _mm256_mul_ps(aVal, bVal);
+++ cVal = _mm256_mul_ps(aVal, bVal);
++
++- _mm256_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_x2_multiply_32f_generic(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_multiply_32f_generic(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -213,72 +217,74 @@ volk_32f_x2_multiply_32f_generic(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_x2_multiply_32f_a_sse(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_multiply_32f_a_sse(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m128 aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
+++ __m128 aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm_load_ps(aPtr);
++- bVal = _mm_load_ps(bPtr);
+++ aVal = _mm_load_ps(aPtr);
+++ bVal = _mm_load_ps(bPtr);
++
++- cVal = _mm_mul_ps(aVal, bVal);
+++ cVal = _mm_mul_ps(aVal, bVal);
++
++- _mm_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_multiply_32f_a_avx512f(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_multiply_32f_a_avx512f(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m512 aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
+++ __m512 aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
++
++- aVal = _mm512_load_ps(aPtr);
++- bVal = _mm512_load_ps(bPtr);
+++ aVal = _mm512_load_ps(aPtr);
+++ bVal = _mm512_load_ps(bPtr);
++
++- cVal = _mm512_mul_ps(aVal, bVal);
+++ cVal = _mm512_mul_ps(aVal, bVal);
++
++- _mm512_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm512_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++@@ -286,36 +292,37 @@ volk_32f_x2_multiply_32f_a_avx512f(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_multiply_32f_a_avx(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_multiply_32f_a_avx(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m256 aVal, bVal, cVal;
++- for(;number < eighthPoints; number++){
+++ __m256 aVal, bVal, cVal;
+++ for (; number < eighthPoints; number++) {
++
++- aVal = _mm256_load_ps(aPtr);
++- bVal = _mm256_load_ps(bPtr);
+++ aVal = _mm256_load_ps(aPtr);
+++ bVal = _mm256_load_ps(bPtr);
++
++- cVal = _mm256_mul_ps(aVal, bVal);
+++ cVal = _mm256_mul_ps(aVal, bVal);
++
++- _mm256_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -323,57 +330,61 @@ volk_32f_x2_multiply_32f_a_avx(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32f_x2_multiply_32f_neon(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_multiply_32f_neon(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- const unsigned int quarter_points = num_points / 4;
++- unsigned int number;
++- float32x4_t avec, bvec, cvec;
++- for(number=0; number < quarter_points; ++number) {
++- avec = vld1q_f32(aVector);
++- bvec = vld1q_f32(bVector);
++- cvec = vmulq_f32(avec, bvec);
++- vst1q_f32(cVector, cvec);
++- aVector += 4;
++- bVector += 4;
++- cVector += 4;
++- }
++- for(number=quarter_points*4; number < num_points; ++number) {
++- *cVector++ = *aVector++ * *bVector++;
++- }
+++ const unsigned int quarter_points = num_points / 4;
+++ unsigned int number;
+++ float32x4_t avec, bvec, cvec;
+++ for (number = 0; number < quarter_points; ++number) {
+++ avec = vld1q_f32(aVector);
+++ bvec = vld1q_f32(bVector);
+++ cvec = vmulq_f32(avec, bvec);
+++ vst1q_f32(cVector, cvec);
+++ aVector += 4;
+++ bVector += 4;
+++ cVector += 4;
+++ }
+++ for (number = quarter_points * 4; number < num_points; ++number) {
+++ *cVector++ = *aVector++ * *bVector++;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_x2_multiply_32f_a_generic(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_multiply_32f_a_generic(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++ #ifdef LV_HAVE_ORC
++-extern void
++-volk_32f_x2_multiply_32f_a_orc_impl(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points);
++-
++-static inline void
++-volk_32f_x2_multiply_32f_u_orc(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++extern void volk_32f_x2_multiply_32f_a_orc_impl(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points);
+++
+++static inline void volk_32f_x2_multiply_32f_u_orc(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- volk_32f_x2_multiply_32f_a_orc_impl(cVector, aVector, bVector, num_points);
+++ volk_32f_x2_multiply_32f_a_orc_impl(cVector, aVector, bVector, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++diff --git a/kernels/volk/volk_32f_x2_pow_32f.h b/kernels/volk/volk_32f_x2_pow_32f.h
++index daa7f4e..106c57b 100644
++--- a/kernels/volk/volk_32f_x2_pow_32f.h
+++++ b/kernels/volk/volk_32f_x2_pow_32f.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_x2_pow_32f(float* cVector, const float* bVector, const float* aVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_x2_pow_32f(float* cVector, const float* bVector, const float* aVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li bVector: The input vector of indices (power values).
++@@ -71,10 +71,10 @@
++ #ifndef INCLUDED_volk_32f_x2_pow_32f_a_H
++ #define INCLUDED_volk_32f_x2_pow_32f_a_H
++
++-#include <stdio.h>
++-#include <stdlib.h>
++ #include <inttypes.h>
++ #include <math.h>
+++#include <stdio.h>
+++#include <stdlib.h>
++
++ #define POW_POLY_DEGREE 3
++
++@@ -82,99 +82,130 @@
++ #include <immintrin.h>
++
++ #define POLY0_AVX2_FMA(x, c0) _mm256_set1_ps(c0)
++-#define POLY1_AVX2_FMA(x, c0, c1) _mm256_fmadd_ps(POLY0_AVX2_FMA(x, c1), x, _mm256_set1_ps(c0))
++-#define POLY2_AVX2_FMA(x, c0, c1, c2) _mm256_fmadd_ps(POLY1_AVX2_FMA(x, c1, c2), x, _mm256_set1_ps(c0))
++-#define POLY3_AVX2_FMA(x, c0, c1, c2, c3) _mm256_fmadd_ps(POLY2_AVX2_FMA(x, c1, c2, c3), x, _mm256_set1_ps(c0))
++-#define POLY4_AVX2_FMA(x, c0, c1, c2, c3, c4) _mm256_fmadd_ps(POLY3_AVX2_FMA(x, c1, c2, c3, c4), x, _mm256_set1_ps(c0))
++-#define POLY5_AVX2_FMA(x, c0, c1, c2, c3, c4, c5) _mm256_fmadd_ps(POLY4_AVX2_FMA(x, c1, c2, c3, c4, c5), x, _mm256_set1_ps(c0))
++-
++-static inline void
++-volk_32f_x2_pow_32f_a_avx2_fma(float* cVector, const float* bVector,
++- const float* aVector, unsigned int num_points)
+++#define POLY1_AVX2_FMA(x, c0, c1) \
+++ _mm256_fmadd_ps(POLY0_AVX2_FMA(x, c1), x, _mm256_set1_ps(c0))
+++#define POLY2_AVX2_FMA(x, c0, c1, c2) \
+++ _mm256_fmadd_ps(POLY1_AVX2_FMA(x, c1, c2), x, _mm256_set1_ps(c0))
+++#define POLY3_AVX2_FMA(x, c0, c1, c2, c3) \
+++ _mm256_fmadd_ps(POLY2_AVX2_FMA(x, c1, c2, c3), x, _mm256_set1_ps(c0))
+++#define POLY4_AVX2_FMA(x, c0, c1, c2, c3, c4) \
+++ _mm256_fmadd_ps(POLY3_AVX2_FMA(x, c1, c2, c3, c4), x, _mm256_set1_ps(c0))
+++#define POLY5_AVX2_FMA(x, c0, c1, c2, c3, c4, c5) \
+++ _mm256_fmadd_ps(POLY4_AVX2_FMA(x, c1, c2, c3, c4, c5), x, _mm256_set1_ps(c0))
+++
+++static inline void volk_32f_x2_pow_32f_a_avx2_fma(float* cVector,
+++ const float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- __m256 aVal, bVal, cVal, logarithm, mantissa, frac, leadingOne;
++- __m256 tmp, fx, mask, pow2n, z, y;
++- __m256 one, exp_hi, exp_lo, ln2, log2EF, half, exp_C1, exp_C2;
++- __m256 exp_p0, exp_p1, exp_p2, exp_p3, exp_p4, exp_p5;
++- __m256i bias, exp, emm0, pi32_0x7f;
++-
++- one = _mm256_set1_ps(1.0);
++- exp_hi = _mm256_set1_ps(88.3762626647949);
++- exp_lo = _mm256_set1_ps(-88.3762626647949);
++- ln2 = _mm256_set1_ps(0.6931471805);
++- log2EF = _mm256_set1_ps(1.44269504088896341);
++- half = _mm256_set1_ps(0.5);
++- exp_C1 = _mm256_set1_ps(0.693359375);
++- exp_C2 = _mm256_set1_ps(-2.12194440e-4);
++- pi32_0x7f = _mm256_set1_epi32(0x7f);
++-
++- exp_p0 = _mm256_set1_ps(1.9875691500e-4);
++- exp_p1 = _mm256_set1_ps(1.3981999507e-3);
++- exp_p2 = _mm256_set1_ps(8.3334519073e-3);
++- exp_p3 = _mm256_set1_ps(4.1665795894e-2);
++- exp_p4 = _mm256_set1_ps(1.6666665459e-1);
++- exp_p5 = _mm256_set1_ps(5.0000001201e-1);
++-
++- for(;number < eighthPoints; number++){
++- // First compute the logarithm
++- aVal = _mm256_load_ps(aPtr);
++- bias = _mm256_set1_epi32(127);
++- leadingOne = _mm256_set1_ps(1.0f);
++- exp = _mm256_sub_epi32(_mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal), _mm256_set1_epi32(0x7f800000)), 23), bias);
++- logarithm = _mm256_cvtepi32_ps(exp);
++-
++- frac = _mm256_or_ps(leadingOne, _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
+++ float* cPtr = cVector;
+++ const float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ __m256 aVal, bVal, cVal, logarithm, mantissa, frac, leadingOne;
+++ __m256 tmp, fx, mask, pow2n, z, y;
+++ __m256 one, exp_hi, exp_lo, ln2, log2EF, half, exp_C1, exp_C2;
+++ __m256 exp_p0, exp_p1, exp_p2, exp_p3, exp_p4, exp_p5;
+++ __m256i bias, exp, emm0, pi32_0x7f;
+++
+++ one = _mm256_set1_ps(1.0);
+++ exp_hi = _mm256_set1_ps(88.3762626647949);
+++ exp_lo = _mm256_set1_ps(-88.3762626647949);
+++ ln2 = _mm256_set1_ps(0.6931471805);
+++ log2EF = _mm256_set1_ps(1.44269504088896341);
+++ half = _mm256_set1_ps(0.5);
+++ exp_C1 = _mm256_set1_ps(0.693359375);
+++ exp_C2 = _mm256_set1_ps(-2.12194440e-4);
+++ pi32_0x7f = _mm256_set1_epi32(0x7f);
+++
+++ exp_p0 = _mm256_set1_ps(1.9875691500e-4);
+++ exp_p1 = _mm256_set1_ps(1.3981999507e-3);
+++ exp_p2 = _mm256_set1_ps(8.3334519073e-3);
+++ exp_p3 = _mm256_set1_ps(4.1665795894e-2);
+++ exp_p4 = _mm256_set1_ps(1.6666665459e-1);
+++ exp_p5 = _mm256_set1_ps(5.0000001201e-1);
+++
+++ for (; number < eighthPoints; number++) {
+++ // First compute the logarithm
+++ aVal = _mm256_load_ps(aPtr);
+++ bias = _mm256_set1_epi32(127);
+++ leadingOne = _mm256_set1_ps(1.0f);
+++ exp = _mm256_sub_epi32(
+++ _mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal),
+++ _mm256_set1_epi32(0x7f800000)),
+++ 23),
+++ bias);
+++ logarithm = _mm256_cvtepi32_ps(exp);
+++
+++ frac = _mm256_or_ps(
+++ leadingOne,
+++ _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
++
++ #if POW_POLY_DEGREE == 6
++- mantissa = POLY5_AVX2_FMA( frac, 3.1157899f, -3.3241990f, 2.5988452f, -1.2315303f, 3.1821337e-1f, -3.4436006e-2f);
+++ mantissa = POLY5_AVX2_FMA(frac,
+++ 3.1157899f,
+++ -3.3241990f,
+++ 2.5988452f,
+++ -1.2315303f,
+++ 3.1821337e-1f,
+++ -3.4436006e-2f);
++ #elif POW_POLY_DEGREE == 5
++- mantissa = POLY4_AVX2_FMA( frac, 2.8882704548164776201f, -2.52074962577807006663f, 1.48116647521213171641f, -0.465725644288844778798f, 0.0596515482674574969533f);
+++ mantissa = POLY4_AVX2_FMA(frac,
+++ 2.8882704548164776201f,
+++ -2.52074962577807006663f,
+++ 1.48116647521213171641f,
+++ -0.465725644288844778798f,
+++ 0.0596515482674574969533f);
++ #elif POW_POLY_DEGREE == 4
++- mantissa = POLY3_AVX2_FMA( frac, 2.61761038894603480148f, -1.75647175389045657003f, 0.688243882994381274313f, -0.107254423828329604454f);
+++ mantissa = POLY3_AVX2_FMA(frac,
+++ 2.61761038894603480148f,
+++ -1.75647175389045657003f,
+++ 0.688243882994381274313f,
+++ -0.107254423828329604454f);
++ #elif POW_POLY_DEGREE == 3
++- mantissa = POLY2_AVX2_FMA( frac, 2.28330284476918490682f, -1.04913055217340124191f, 0.204446009836232697516f);
+++ mantissa = POLY2_AVX2_FMA(frac,
+++ 2.28330284476918490682f,
+++ -1.04913055217340124191f,
+++ 0.204446009836232697516f);
++ #else
++ #error
++ #endif
++
++- logarithm = _mm256_fmadd_ps(mantissa, _mm256_sub_ps(frac, leadingOne), logarithm);
++- logarithm = _mm256_mul_ps(logarithm, ln2);
+++ logarithm = _mm256_fmadd_ps(mantissa, _mm256_sub_ps(frac, leadingOne), logarithm);
+++ logarithm = _mm256_mul_ps(logarithm, ln2);
++
++- // Now calculate b*lna
++- bVal = _mm256_load_ps(bPtr);
++- bVal = _mm256_mul_ps(bVal, logarithm);
+++ // Now calculate b*lna
+++ bVal = _mm256_load_ps(bPtr);
+++ bVal = _mm256_mul_ps(bVal, logarithm);
++
++- // Now compute exp(b*lna)
++- bVal = _mm256_max_ps(_mm256_min_ps(bVal, exp_hi), exp_lo);
+++ // Now compute exp(b*lna)
+++ bVal = _mm256_max_ps(_mm256_min_ps(bVal, exp_hi), exp_lo);
++
++- fx = _mm256_fmadd_ps(bVal, log2EF, half);
+++ fx = _mm256_fmadd_ps(bVal, log2EF, half);
++
++- emm0 = _mm256_cvttps_epi32(fx);
++- tmp = _mm256_cvtepi32_ps(emm0);
+++ emm0 = _mm256_cvttps_epi32(fx);
+++ tmp = _mm256_cvtepi32_ps(emm0);
++
++- mask = _mm256_and_ps(_mm256_cmp_ps(tmp, fx, _CMP_GT_OS), one);
++- fx = _mm256_sub_ps(tmp, mask);
+++ mask = _mm256_and_ps(_mm256_cmp_ps(tmp, fx, _CMP_GT_OS), one);
+++ fx = _mm256_sub_ps(tmp, mask);
++
++- tmp = _mm256_fnmadd_ps(fx, exp_C1, bVal);
++- bVal = _mm256_fnmadd_ps(fx, exp_C2, tmp);
++- z = _mm256_mul_ps(bVal, bVal);
+++ tmp = _mm256_fnmadd_ps(fx, exp_C1, bVal);
+++ bVal = _mm256_fnmadd_ps(fx, exp_C2, tmp);
+++ z = _mm256_mul_ps(bVal, bVal);
++
++- y = _mm256_fmadd_ps(exp_p0, bVal, exp_p1);
++- y = _mm256_fmadd_ps(y, bVal, exp_p2);
++- y = _mm256_fmadd_ps(y, bVal, exp_p3);
++- y = _mm256_fmadd_ps(y, bVal, exp_p4);
++- y = _mm256_fmadd_ps(y, bVal, exp_p5);
++- y = _mm256_fmadd_ps(y, z, bVal);
++- y = _mm256_add_ps(y, one);
+++ y = _mm256_fmadd_ps(exp_p0, bVal, exp_p1);
+++ y = _mm256_fmadd_ps(y, bVal, exp_p2);
+++ y = _mm256_fmadd_ps(y, bVal, exp_p3);
+++ y = _mm256_fmadd_ps(y, bVal, exp_p4);
+++ y = _mm256_fmadd_ps(y, bVal, exp_p5);
+++ y = _mm256_fmadd_ps(y, z, bVal);
+++ y = _mm256_add_ps(y, one);
++
++- emm0 = _mm256_slli_epi32(_mm256_add_epi32(_mm256_cvttps_epi32(fx), pi32_0x7f), 23);
+++ emm0 =
+++ _mm256_slli_epi32(_mm256_add_epi32(_mm256_cvttps_epi32(fx), pi32_0x7f), 23);
++
++ pow2n = _mm256_castsi256_ps(emm0);
++ cVal = _mm256_mul_ps(y, pow2n);
++@@ -184,12 +215,12 @@ volk_32f_x2_pow_32f_a_avx2_fma(float* cVector, const float* bVector,
++ aPtr += 8;
++ bPtr += 8;
++ cPtr += 8;
++- }
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = pow(*aPtr++, *bPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = pow(*aPtr++, *bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for aligned */
++@@ -198,99 +229,131 @@ volk_32f_x2_pow_32f_a_avx2_fma(float* cVector, const float* bVector,
++ #include <immintrin.h>
++
++ #define POLY0_AVX2(x, c0) _mm256_set1_ps(c0)
++-#define POLY1_AVX2(x, c0, c1) _mm256_add_ps(_mm256_mul_ps(POLY0_AVX2(x, c1), x), _mm256_set1_ps(c0))
++-#define POLY2_AVX2(x, c0, c1, c2) _mm256_add_ps(_mm256_mul_ps(POLY1_AVX2(x, c1, c2), x), _mm256_set1_ps(c0))
++-#define POLY3_AVX2(x, c0, c1, c2, c3) _mm256_add_ps(_mm256_mul_ps(POLY2_AVX2(x, c1, c2, c3), x), _mm256_set1_ps(c0))
++-#define POLY4_AVX2(x, c0, c1, c2, c3, c4) _mm256_add_ps(_mm256_mul_ps(POLY3_AVX2(x, c1, c2, c3, c4), x), _mm256_set1_ps(c0))
++-#define POLY5_AVX2(x, c0, c1, c2, c3, c4, c5) _mm256_add_ps(_mm256_mul_ps(POLY4_AVX2(x, c1, c2, c3, c4, c5), x), _mm256_set1_ps(c0))
++-
++-static inline void
++-volk_32f_x2_pow_32f_a_avx2(float* cVector, const float* bVector,
++- const float* aVector, unsigned int num_points)
+++#define POLY1_AVX2(x, c0, c1) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY0_AVX2(x, c1), x), _mm256_set1_ps(c0))
+++#define POLY2_AVX2(x, c0, c1, c2) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY1_AVX2(x, c1, c2), x), _mm256_set1_ps(c0))
+++#define POLY3_AVX2(x, c0, c1, c2, c3) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY2_AVX2(x, c1, c2, c3), x), _mm256_set1_ps(c0))
+++#define POLY4_AVX2(x, c0, c1, c2, c3, c4) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY3_AVX2(x, c1, c2, c3, c4), x), _mm256_set1_ps(c0))
+++#define POLY5_AVX2(x, c0, c1, c2, c3, c4, c5) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY4_AVX2(x, c1, c2, c3, c4, c5), x), _mm256_set1_ps(c0))
+++
+++static inline void volk_32f_x2_pow_32f_a_avx2(float* cVector,
+++ const float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- __m256 aVal, bVal, cVal, logarithm, mantissa, frac, leadingOne;
++- __m256 tmp, fx, mask, pow2n, z, y;
++- __m256 one, exp_hi, exp_lo, ln2, log2EF, half, exp_C1, exp_C2;
++- __m256 exp_p0, exp_p1, exp_p2, exp_p3, exp_p4, exp_p5;
++- __m256i bias, exp, emm0, pi32_0x7f;
++-
++- one = _mm256_set1_ps(1.0);
++- exp_hi = _mm256_set1_ps(88.3762626647949);
++- exp_lo = _mm256_set1_ps(-88.3762626647949);
++- ln2 = _mm256_set1_ps(0.6931471805);
++- log2EF = _mm256_set1_ps(1.44269504088896341);
++- half = _mm256_set1_ps(0.5);
++- exp_C1 = _mm256_set1_ps(0.693359375);
++- exp_C2 = _mm256_set1_ps(-2.12194440e-4);
++- pi32_0x7f = _mm256_set1_epi32(0x7f);
++-
++- exp_p0 = _mm256_set1_ps(1.9875691500e-4);
++- exp_p1 = _mm256_set1_ps(1.3981999507e-3);
++- exp_p2 = _mm256_set1_ps(8.3334519073e-3);
++- exp_p3 = _mm256_set1_ps(4.1665795894e-2);
++- exp_p4 = _mm256_set1_ps(1.6666665459e-1);
++- exp_p5 = _mm256_set1_ps(5.0000001201e-1);
++-
++- for(;number < eighthPoints; number++){
++- // First compute the logarithm
++- aVal = _mm256_load_ps(aPtr);
++- bias = _mm256_set1_epi32(127);
++- leadingOne = _mm256_set1_ps(1.0f);
++- exp = _mm256_sub_epi32(_mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal), _mm256_set1_epi32(0x7f800000)), 23), bias);
++- logarithm = _mm256_cvtepi32_ps(exp);
++-
++- frac = _mm256_or_ps(leadingOne, _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
+++ float* cPtr = cVector;
+++ const float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ __m256 aVal, bVal, cVal, logarithm, mantissa, frac, leadingOne;
+++ __m256 tmp, fx, mask, pow2n, z, y;
+++ __m256 one, exp_hi, exp_lo, ln2, log2EF, half, exp_C1, exp_C2;
+++ __m256 exp_p0, exp_p1, exp_p2, exp_p3, exp_p4, exp_p5;
+++ __m256i bias, exp, emm0, pi32_0x7f;
+++
+++ one = _mm256_set1_ps(1.0);
+++ exp_hi = _mm256_set1_ps(88.3762626647949);
+++ exp_lo = _mm256_set1_ps(-88.3762626647949);
+++ ln2 = _mm256_set1_ps(0.6931471805);
+++ log2EF = _mm256_set1_ps(1.44269504088896341);
+++ half = _mm256_set1_ps(0.5);
+++ exp_C1 = _mm256_set1_ps(0.693359375);
+++ exp_C2 = _mm256_set1_ps(-2.12194440e-4);
+++ pi32_0x7f = _mm256_set1_epi32(0x7f);
+++
+++ exp_p0 = _mm256_set1_ps(1.9875691500e-4);
+++ exp_p1 = _mm256_set1_ps(1.3981999507e-3);
+++ exp_p2 = _mm256_set1_ps(8.3334519073e-3);
+++ exp_p3 = _mm256_set1_ps(4.1665795894e-2);
+++ exp_p4 = _mm256_set1_ps(1.6666665459e-1);
+++ exp_p5 = _mm256_set1_ps(5.0000001201e-1);
+++
+++ for (; number < eighthPoints; number++) {
+++ // First compute the logarithm
+++ aVal = _mm256_load_ps(aPtr);
+++ bias = _mm256_set1_epi32(127);
+++ leadingOne = _mm256_set1_ps(1.0f);
+++ exp = _mm256_sub_epi32(
+++ _mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal),
+++ _mm256_set1_epi32(0x7f800000)),
+++ 23),
+++ bias);
+++ logarithm = _mm256_cvtepi32_ps(exp);
+++
+++ frac = _mm256_or_ps(
+++ leadingOne,
+++ _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
++
++ #if POW_POLY_DEGREE == 6
++- mantissa = POLY5_AVX2( frac, 3.1157899f, -3.3241990f, 2.5988452f, -1.2315303f, 3.1821337e-1f, -3.4436006e-2f);
+++ mantissa = POLY5_AVX2(frac,
+++ 3.1157899f,
+++ -3.3241990f,
+++ 2.5988452f,
+++ -1.2315303f,
+++ 3.1821337e-1f,
+++ -3.4436006e-2f);
++ #elif POW_POLY_DEGREE == 5
++- mantissa = POLY4_AVX2( frac, 2.8882704548164776201f, -2.52074962577807006663f, 1.48116647521213171641f, -0.465725644288844778798f, 0.0596515482674574969533f);
+++ mantissa = POLY4_AVX2(frac,
+++ 2.8882704548164776201f,
+++ -2.52074962577807006663f,
+++ 1.48116647521213171641f,
+++ -0.465725644288844778798f,
+++ 0.0596515482674574969533f);
++ #elif POW_POLY_DEGREE == 4
++- mantissa = POLY3_AVX2( frac, 2.61761038894603480148f, -1.75647175389045657003f, 0.688243882994381274313f, -0.107254423828329604454f);
+++ mantissa = POLY3_AVX2(frac,
+++ 2.61761038894603480148f,
+++ -1.75647175389045657003f,
+++ 0.688243882994381274313f,
+++ -0.107254423828329604454f);
++ #elif POW_POLY_DEGREE == 3
++- mantissa = POLY2_AVX2( frac, 2.28330284476918490682f, -1.04913055217340124191f, 0.204446009836232697516f);
+++ mantissa = POLY2_AVX2(frac,
+++ 2.28330284476918490682f,
+++ -1.04913055217340124191f,
+++ 0.204446009836232697516f);
++ #else
++ #error
++ #endif
++
++- logarithm = _mm256_add_ps(_mm256_mul_ps(mantissa, _mm256_sub_ps(frac, leadingOne)), logarithm);
++- logarithm = _mm256_mul_ps(logarithm, ln2);
+++ logarithm = _mm256_add_ps(
+++ _mm256_mul_ps(mantissa, _mm256_sub_ps(frac, leadingOne)), logarithm);
+++ logarithm = _mm256_mul_ps(logarithm, ln2);
++
++- // Now calculate b*lna
++- bVal = _mm256_load_ps(bPtr);
++- bVal = _mm256_mul_ps(bVal, logarithm);
+++ // Now calculate b*lna
+++ bVal = _mm256_load_ps(bPtr);
+++ bVal = _mm256_mul_ps(bVal, logarithm);
++
++- // Now compute exp(b*lna)
++- bVal = _mm256_max_ps(_mm256_min_ps(bVal, exp_hi), exp_lo);
+++ // Now compute exp(b*lna)
+++ bVal = _mm256_max_ps(_mm256_min_ps(bVal, exp_hi), exp_lo);
++
++- fx = _mm256_add_ps(_mm256_mul_ps(bVal, log2EF), half);
+++ fx = _mm256_add_ps(_mm256_mul_ps(bVal, log2EF), half);
++
++- emm0 = _mm256_cvttps_epi32(fx);
++- tmp = _mm256_cvtepi32_ps(emm0);
+++ emm0 = _mm256_cvttps_epi32(fx);
+++ tmp = _mm256_cvtepi32_ps(emm0);
++
++- mask = _mm256_and_ps(_mm256_cmp_ps(tmp, fx, _CMP_GT_OS), one);
++- fx = _mm256_sub_ps(tmp, mask);
+++ mask = _mm256_and_ps(_mm256_cmp_ps(tmp, fx, _CMP_GT_OS), one);
+++ fx = _mm256_sub_ps(tmp, mask);
++
++- tmp = _mm256_sub_ps(bVal, _mm256_mul_ps(fx, exp_C1));
++- bVal = _mm256_sub_ps(tmp, _mm256_mul_ps(fx, exp_C2));
++- z = _mm256_mul_ps(bVal, bVal);
+++ tmp = _mm256_sub_ps(bVal, _mm256_mul_ps(fx, exp_C1));
+++ bVal = _mm256_sub_ps(tmp, _mm256_mul_ps(fx, exp_C2));
+++ z = _mm256_mul_ps(bVal, bVal);
++
++- y = _mm256_add_ps(_mm256_mul_ps(exp_p0, bVal), exp_p1);
++- y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p2);
++- y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p3);
++- y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p4);
++- y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p5);
++- y = _mm256_add_ps(_mm256_mul_ps(y, z), bVal);
++- y = _mm256_add_ps(y, one);
+++ y = _mm256_add_ps(_mm256_mul_ps(exp_p0, bVal), exp_p1);
+++ y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p2);
+++ y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p3);
+++ y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p4);
+++ y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p5);
+++ y = _mm256_add_ps(_mm256_mul_ps(y, z), bVal);
+++ y = _mm256_add_ps(y, one);
++
++- emm0 = _mm256_slli_epi32(_mm256_add_epi32(_mm256_cvttps_epi32(fx), pi32_0x7f), 23);
+++ emm0 =
+++ _mm256_slli_epi32(_mm256_add_epi32(_mm256_cvttps_epi32(fx), pi32_0x7f), 23);
++
++ pow2n = _mm256_castsi256_ps(emm0);
++ cVal = _mm256_mul_ps(y, pow2n);
++@@ -300,12 +363,12 @@ volk_32f_x2_pow_32f_a_avx2(float* cVector, const float* bVector,
++ aPtr += 8;
++ bPtr += 8;
++ cPtr += 8;
++- }
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = pow(*aPtr++, *bPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = pow(*aPtr++, *bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 for aligned */
++@@ -317,97 +380,124 @@ volk_32f_x2_pow_32f_a_avx2(float* cVector, const float* bVector,
++ #define POLY0(x, c0) _mm_set1_ps(c0)
++ #define POLY1(x, c0, c1) _mm_add_ps(_mm_mul_ps(POLY0(x, c1), x), _mm_set1_ps(c0))
++ #define POLY2(x, c0, c1, c2) _mm_add_ps(_mm_mul_ps(POLY1(x, c1, c2), x), _mm_set1_ps(c0))
++-#define POLY3(x, c0, c1, c2, c3) _mm_add_ps(_mm_mul_ps(POLY2(x, c1, c2, c3), x), _mm_set1_ps(c0))
++-#define POLY4(x, c0, c1, c2, c3, c4) _mm_add_ps(_mm_mul_ps(POLY3(x, c1, c2, c3, c4), x), _mm_set1_ps(c0))
++-#define POLY5(x, c0, c1, c2, c3, c4, c5) _mm_add_ps(_mm_mul_ps(POLY4(x, c1, c2, c3, c4, c5), x), _mm_set1_ps(c0))
++-
++-static inline void
++-volk_32f_x2_pow_32f_a_sse4_1(float* cVector, const float* bVector,
++- const float* aVector, unsigned int num_points)
+++#define POLY3(x, c0, c1, c2, c3) \
+++ _mm_add_ps(_mm_mul_ps(POLY2(x, c1, c2, c3), x), _mm_set1_ps(c0))
+++#define POLY4(x, c0, c1, c2, c3, c4) \
+++ _mm_add_ps(_mm_mul_ps(POLY3(x, c1, c2, c3, c4), x), _mm_set1_ps(c0))
+++#define POLY5(x, c0, c1, c2, c3, c4, c5) \
+++ _mm_add_ps(_mm_mul_ps(POLY4(x, c1, c2, c3, c4, c5), x), _mm_set1_ps(c0))
+++
+++static inline void volk_32f_x2_pow_32f_a_sse4_1(float* cVector,
+++ const float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- __m128 aVal, bVal, cVal, logarithm, mantissa, frac, leadingOne;
++- __m128 tmp, fx, mask, pow2n, z, y;
++- __m128 one, exp_hi, exp_lo, ln2, log2EF, half, exp_C1, exp_C2;
++- __m128 exp_p0, exp_p1, exp_p2, exp_p3, exp_p4, exp_p5;
++- __m128i bias, exp, emm0, pi32_0x7f;
++-
++- one = _mm_set1_ps(1.0);
++- exp_hi = _mm_set1_ps(88.3762626647949);
++- exp_lo = _mm_set1_ps(-88.3762626647949);
++- ln2 = _mm_set1_ps(0.6931471805);
++- log2EF = _mm_set1_ps(1.44269504088896341);
++- half = _mm_set1_ps(0.5);
++- exp_C1 = _mm_set1_ps(0.693359375);
++- exp_C2 = _mm_set1_ps(-2.12194440e-4);
++- pi32_0x7f = _mm_set1_epi32(0x7f);
++-
++- exp_p0 = _mm_set1_ps(1.9875691500e-4);
++- exp_p1 = _mm_set1_ps(1.3981999507e-3);
++- exp_p2 = _mm_set1_ps(8.3334519073e-3);
++- exp_p3 = _mm_set1_ps(4.1665795894e-2);
++- exp_p4 = _mm_set1_ps(1.6666665459e-1);
++- exp_p5 = _mm_set1_ps(5.0000001201e-1);
++-
++- for(;number < quarterPoints; number++){
++- // First compute the logarithm
++- aVal = _mm_load_ps(aPtr);
++- bias = _mm_set1_epi32(127);
++- leadingOne = _mm_set1_ps(1.0f);
++- exp = _mm_sub_epi32(_mm_srli_epi32(_mm_and_si128(_mm_castps_si128(aVal), _mm_set1_epi32(0x7f800000)), 23), bias);
++- logarithm = _mm_cvtepi32_ps(exp);
++-
++- frac = _mm_or_ps(leadingOne, _mm_and_ps(aVal, _mm_castsi128_ps(_mm_set1_epi32(0x7fffff))));
+++ float* cPtr = cVector;
+++ const float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ __m128 aVal, bVal, cVal, logarithm, mantissa, frac, leadingOne;
+++ __m128 tmp, fx, mask, pow2n, z, y;
+++ __m128 one, exp_hi, exp_lo, ln2, log2EF, half, exp_C1, exp_C2;
+++ __m128 exp_p0, exp_p1, exp_p2, exp_p3, exp_p4, exp_p5;
+++ __m128i bias, exp, emm0, pi32_0x7f;
+++
+++ one = _mm_set1_ps(1.0);
+++ exp_hi = _mm_set1_ps(88.3762626647949);
+++ exp_lo = _mm_set1_ps(-88.3762626647949);
+++ ln2 = _mm_set1_ps(0.6931471805);
+++ log2EF = _mm_set1_ps(1.44269504088896341);
+++ half = _mm_set1_ps(0.5);
+++ exp_C1 = _mm_set1_ps(0.693359375);
+++ exp_C2 = _mm_set1_ps(-2.12194440e-4);
+++ pi32_0x7f = _mm_set1_epi32(0x7f);
+++
+++ exp_p0 = _mm_set1_ps(1.9875691500e-4);
+++ exp_p1 = _mm_set1_ps(1.3981999507e-3);
+++ exp_p2 = _mm_set1_ps(8.3334519073e-3);
+++ exp_p3 = _mm_set1_ps(4.1665795894e-2);
+++ exp_p4 = _mm_set1_ps(1.6666665459e-1);
+++ exp_p5 = _mm_set1_ps(5.0000001201e-1);
+++
+++ for (; number < quarterPoints; number++) {
+++ // First compute the logarithm
+++ aVal = _mm_load_ps(aPtr);
+++ bias = _mm_set1_epi32(127);
+++ leadingOne = _mm_set1_ps(1.0f);
+++ exp = _mm_sub_epi32(
+++ _mm_srli_epi32(
+++ _mm_and_si128(_mm_castps_si128(aVal), _mm_set1_epi32(0x7f800000)), 23),
+++ bias);
+++ logarithm = _mm_cvtepi32_ps(exp);
+++
+++ frac = _mm_or_ps(leadingOne,
+++ _mm_and_ps(aVal, _mm_castsi128_ps(_mm_set1_epi32(0x7fffff))));
++
++ #if POW_POLY_DEGREE == 6
++- mantissa = POLY5( frac, 3.1157899f, -3.3241990f, 2.5988452f, -1.2315303f, 3.1821337e-1f, -3.4436006e-2f);
+++ mantissa = POLY5(frac,
+++ 3.1157899f,
+++ -3.3241990f,
+++ 2.5988452f,
+++ -1.2315303f,
+++ 3.1821337e-1f,
+++ -3.4436006e-2f);
++ #elif POW_POLY_DEGREE == 5
++- mantissa = POLY4( frac, 2.8882704548164776201f, -2.52074962577807006663f, 1.48116647521213171641f, -0.465725644288844778798f, 0.0596515482674574969533f);
+++ mantissa = POLY4(frac,
+++ 2.8882704548164776201f,
+++ -2.52074962577807006663f,
+++ 1.48116647521213171641f,
+++ -0.465725644288844778798f,
+++ 0.0596515482674574969533f);
++ #elif POW_POLY_DEGREE == 4
++- mantissa = POLY3( frac, 2.61761038894603480148f, -1.75647175389045657003f, 0.688243882994381274313f, -0.107254423828329604454f);
+++ mantissa = POLY3(frac,
+++ 2.61761038894603480148f,
+++ -1.75647175389045657003f,
+++ 0.688243882994381274313f,
+++ -0.107254423828329604454f);
++ #elif POW_POLY_DEGREE == 3
++- mantissa = POLY2( frac, 2.28330284476918490682f, -1.04913055217340124191f, 0.204446009836232697516f);
+++ mantissa = POLY2(frac,
+++ 2.28330284476918490682f,
+++ -1.04913055217340124191f,
+++ 0.204446009836232697516f);
++ #else
++ #error
++ #endif
++
++- logarithm = _mm_add_ps(logarithm, _mm_mul_ps(mantissa, _mm_sub_ps(frac, leadingOne)));
++- logarithm = _mm_mul_ps(logarithm, ln2);
+++ logarithm =
+++ _mm_add_ps(logarithm, _mm_mul_ps(mantissa, _mm_sub_ps(frac, leadingOne)));
+++ logarithm = _mm_mul_ps(logarithm, ln2);
++
++
++- // Now calculate b*lna
++- bVal = _mm_load_ps(bPtr);
++- bVal = _mm_mul_ps(bVal, logarithm);
+++ // Now calculate b*lna
+++ bVal = _mm_load_ps(bPtr);
+++ bVal = _mm_mul_ps(bVal, logarithm);
++
++- // Now compute exp(b*lna)
++- bVal = _mm_max_ps(_mm_min_ps(bVal, exp_hi), exp_lo);
+++ // Now compute exp(b*lna)
+++ bVal = _mm_max_ps(_mm_min_ps(bVal, exp_hi), exp_lo);
++
++- fx = _mm_add_ps(_mm_mul_ps(bVal, log2EF), half);
+++ fx = _mm_add_ps(_mm_mul_ps(bVal, log2EF), half);
++
++- emm0 = _mm_cvttps_epi32(fx);
++- tmp = _mm_cvtepi32_ps(emm0);
+++ emm0 = _mm_cvttps_epi32(fx);
+++ tmp = _mm_cvtepi32_ps(emm0);
++
++- mask = _mm_and_ps(_mm_cmpgt_ps(tmp, fx), one);
++- fx = _mm_sub_ps(tmp, mask);
+++ mask = _mm_and_ps(_mm_cmpgt_ps(tmp, fx), one);
+++ fx = _mm_sub_ps(tmp, mask);
++
++- tmp = _mm_mul_ps(fx, exp_C1);
++- z = _mm_mul_ps(fx, exp_C2);
++- bVal = _mm_sub_ps(_mm_sub_ps(bVal, tmp), z);
++- z = _mm_mul_ps(bVal, bVal);
+++ tmp = _mm_mul_ps(fx, exp_C1);
+++ z = _mm_mul_ps(fx, exp_C2);
+++ bVal = _mm_sub_ps(_mm_sub_ps(bVal, tmp), z);
+++ z = _mm_mul_ps(bVal, bVal);
++
++- y = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(exp_p0, bVal), exp_p1), bVal);
++- y = _mm_add_ps(_mm_mul_ps(_mm_add_ps(y, exp_p2), bVal), exp_p3);
++- y = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(y, bVal), exp_p4), bVal);
++- y = _mm_add_ps(_mm_mul_ps(_mm_add_ps(y, exp_p5), z), bVal);
++- y = _mm_add_ps(y, one);
+++ y = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(exp_p0, bVal), exp_p1), bVal);
+++ y = _mm_add_ps(_mm_mul_ps(_mm_add_ps(y, exp_p2), bVal), exp_p3);
+++ y = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(y, bVal), exp_p4), bVal);
+++ y = _mm_add_ps(_mm_mul_ps(_mm_add_ps(y, exp_p5), z), bVal);
+++ y = _mm_add_ps(y, one);
++
++- emm0 = _mm_slli_epi32(_mm_add_epi32(_mm_cvttps_epi32(fx), pi32_0x7f), 23);
+++ emm0 = _mm_slli_epi32(_mm_add_epi32(_mm_cvttps_epi32(fx), pi32_0x7f), 23);
++
++ pow2n = _mm_castsi128_ps(emm0);
++ cVal = _mm_mul_ps(y, pow2n);
++@@ -417,12 +507,12 @@ volk_32f_x2_pow_32f_a_sse4_1(float* cVector, const float* bVector,
++ aPtr += 4;
++ bPtr += 4;
++ cPtr += 4;
++- }
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *cPtr++ = powf(*aPtr++, *bPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = powf(*aPtr++, *bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for aligned */
++@@ -432,27 +522,28 @@ volk_32f_x2_pow_32f_a_sse4_1(float* cVector, const float* bVector,
++ #ifndef INCLUDED_volk_32f_x2_pow_32f_u_H
++ #define INCLUDED_volk_32f_x2_pow_32f_u_H
++
++-#include <stdio.h>
++-#include <stdlib.h>
++ #include <inttypes.h>
++ #include <math.h>
+++#include <stdio.h>
+++#include <stdlib.h>
++
++ #define POW_POLY_DEGREE 3
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_x2_pow_32f_generic(float* cVector, const float* bVector,
++- const float* aVector, unsigned int num_points)
+++static inline void volk_32f_x2_pow_32f_generic(float* cVector,
+++ const float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* bPtr = bVector;
++- const float* aPtr = aVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = powf(*aPtr++, *bPtr++);
++- }
+++ float* cPtr = cVector;
+++ const float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = powf(*aPtr++, *bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -463,112 +554,139 @@ volk_32f_x2_pow_32f_generic(float* cVector, const float* bVector,
++ #define POLY0(x, c0) _mm_set1_ps(c0)
++ #define POLY1(x, c0, c1) _mm_add_ps(_mm_mul_ps(POLY0(x, c1), x), _mm_set1_ps(c0))
++ #define POLY2(x, c0, c1, c2) _mm_add_ps(_mm_mul_ps(POLY1(x, c1, c2), x), _mm_set1_ps(c0))
++-#define POLY3(x, c0, c1, c2, c3) _mm_add_ps(_mm_mul_ps(POLY2(x, c1, c2, c3), x), _mm_set1_ps(c0))
++-#define POLY4(x, c0, c1, c2, c3, c4) _mm_add_ps(_mm_mul_ps(POLY3(x, c1, c2, c3, c4), x), _mm_set1_ps(c0))
++-#define POLY5(x, c0, c1, c2, c3, c4, c5) _mm_add_ps(_mm_mul_ps(POLY4(x, c1, c2, c3, c4, c5), x), _mm_set1_ps(c0))
++-
++-static inline void
++-volk_32f_x2_pow_32f_u_sse4_1(float* cVector, const float* bVector,
++- const float* aVector, unsigned int num_points)
+++#define POLY3(x, c0, c1, c2, c3) \
+++ _mm_add_ps(_mm_mul_ps(POLY2(x, c1, c2, c3), x), _mm_set1_ps(c0))
+++#define POLY4(x, c0, c1, c2, c3, c4) \
+++ _mm_add_ps(_mm_mul_ps(POLY3(x, c1, c2, c3, c4), x), _mm_set1_ps(c0))
+++#define POLY5(x, c0, c1, c2, c3, c4, c5) \
+++ _mm_add_ps(_mm_mul_ps(POLY4(x, c1, c2, c3, c4, c5), x), _mm_set1_ps(c0))
+++
+++static inline void volk_32f_x2_pow_32f_u_sse4_1(float* cVector,
+++ const float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- __m128 aVal, bVal, cVal, logarithm, mantissa, frac, leadingOne;
++- __m128 tmp, fx, mask, pow2n, z, y;
++- __m128 one, exp_hi, exp_lo, ln2, log2EF, half, exp_C1, exp_C2;
++- __m128 exp_p0, exp_p1, exp_p2, exp_p3, exp_p4, exp_p5;
++- __m128i bias, exp, emm0, pi32_0x7f;
++-
++- one = _mm_set1_ps(1.0);
++- exp_hi = _mm_set1_ps(88.3762626647949);
++- exp_lo = _mm_set1_ps(-88.3762626647949);
++- ln2 = _mm_set1_ps(0.6931471805);
++- log2EF = _mm_set1_ps(1.44269504088896341);
++- half = _mm_set1_ps(0.5);
++- exp_C1 = _mm_set1_ps(0.693359375);
++- exp_C2 = _mm_set1_ps(-2.12194440e-4);
++- pi32_0x7f = _mm_set1_epi32(0x7f);
++-
++- exp_p0 = _mm_set1_ps(1.9875691500e-4);
++- exp_p1 = _mm_set1_ps(1.3981999507e-3);
++- exp_p2 = _mm_set1_ps(8.3334519073e-3);
++- exp_p3 = _mm_set1_ps(4.1665795894e-2);
++- exp_p4 = _mm_set1_ps(1.6666665459e-1);
++- exp_p5 = _mm_set1_ps(5.0000001201e-1);
++-
++- for(;number < quarterPoints; number++){
++- // First compute the logarithm
++- aVal = _mm_loadu_ps(aPtr);
++- bias = _mm_set1_epi32(127);
++- leadingOne = _mm_set1_ps(1.0f);
++- exp = _mm_sub_epi32(_mm_srli_epi32(_mm_and_si128(_mm_castps_si128(aVal), _mm_set1_epi32(0x7f800000)), 23), bias);
++- logarithm = _mm_cvtepi32_ps(exp);
++-
++- frac = _mm_or_ps(leadingOne, _mm_and_ps(aVal, _mm_castsi128_ps(_mm_set1_epi32(0x7fffff))));
+++ float* cPtr = cVector;
+++ const float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ __m128 aVal, bVal, cVal, logarithm, mantissa, frac, leadingOne;
+++ __m128 tmp, fx, mask, pow2n, z, y;
+++ __m128 one, exp_hi, exp_lo, ln2, log2EF, half, exp_C1, exp_C2;
+++ __m128 exp_p0, exp_p1, exp_p2, exp_p3, exp_p4, exp_p5;
+++ __m128i bias, exp, emm0, pi32_0x7f;
+++
+++ one = _mm_set1_ps(1.0);
+++ exp_hi = _mm_set1_ps(88.3762626647949);
+++ exp_lo = _mm_set1_ps(-88.3762626647949);
+++ ln2 = _mm_set1_ps(0.6931471805);
+++ log2EF = _mm_set1_ps(1.44269504088896341);
+++ half = _mm_set1_ps(0.5);
+++ exp_C1 = _mm_set1_ps(0.693359375);
+++ exp_C2 = _mm_set1_ps(-2.12194440e-4);
+++ pi32_0x7f = _mm_set1_epi32(0x7f);
+++
+++ exp_p0 = _mm_set1_ps(1.9875691500e-4);
+++ exp_p1 = _mm_set1_ps(1.3981999507e-3);
+++ exp_p2 = _mm_set1_ps(8.3334519073e-3);
+++ exp_p3 = _mm_set1_ps(4.1665795894e-2);
+++ exp_p4 = _mm_set1_ps(1.6666665459e-1);
+++ exp_p5 = _mm_set1_ps(5.0000001201e-1);
+++
+++ for (; number < quarterPoints; number++) {
+++ // First compute the logarithm
+++ aVal = _mm_loadu_ps(aPtr);
+++ bias = _mm_set1_epi32(127);
+++ leadingOne = _mm_set1_ps(1.0f);
+++ exp = _mm_sub_epi32(
+++ _mm_srli_epi32(
+++ _mm_and_si128(_mm_castps_si128(aVal), _mm_set1_epi32(0x7f800000)), 23),
+++ bias);
+++ logarithm = _mm_cvtepi32_ps(exp);
+++
+++ frac = _mm_or_ps(leadingOne,
+++ _mm_and_ps(aVal, _mm_castsi128_ps(_mm_set1_epi32(0x7fffff))));
++
++ #if POW_POLY_DEGREE == 6
++- mantissa = POLY5( frac, 3.1157899f, -3.3241990f, 2.5988452f, -1.2315303f, 3.1821337e-1f, -3.4436006e-2f);
+++ mantissa = POLY5(frac,
+++ 3.1157899f,
+++ -3.3241990f,
+++ 2.5988452f,
+++ -1.2315303f,
+++ 3.1821337e-1f,
+++ -3.4436006e-2f);
++ #elif POW_POLY_DEGREE == 5
++- mantissa = POLY4( frac, 2.8882704548164776201f, -2.52074962577807006663f, 1.48116647521213171641f, -0.465725644288844778798f, 0.0596515482674574969533f);
+++ mantissa = POLY4(frac,
+++ 2.8882704548164776201f,
+++ -2.52074962577807006663f,
+++ 1.48116647521213171641f,
+++ -0.465725644288844778798f,
+++ 0.0596515482674574969533f);
++ #elif POW_POLY_DEGREE == 4
++- mantissa = POLY3( frac, 2.61761038894603480148f, -1.75647175389045657003f, 0.688243882994381274313f, -0.107254423828329604454f);
+++ mantissa = POLY3(frac,
+++ 2.61761038894603480148f,
+++ -1.75647175389045657003f,
+++ 0.688243882994381274313f,
+++ -0.107254423828329604454f);
++ #elif POW_POLY_DEGREE == 3
++- mantissa = POLY2( frac, 2.28330284476918490682f, -1.04913055217340124191f, 0.204446009836232697516f);
+++ mantissa = POLY2(frac,
+++ 2.28330284476918490682f,
+++ -1.04913055217340124191f,
+++ 0.204446009836232697516f);
++ #else
++ #error
++ #endif
++
++- logarithm = _mm_add_ps(logarithm, _mm_mul_ps(mantissa, _mm_sub_ps(frac, leadingOne)));
++- logarithm = _mm_mul_ps(logarithm, ln2);
+++ logarithm =
+++ _mm_add_ps(logarithm, _mm_mul_ps(mantissa, _mm_sub_ps(frac, leadingOne)));
+++ logarithm = _mm_mul_ps(logarithm, ln2);
++
++
++- // Now calculate b*lna
++- bVal = _mm_loadu_ps(bPtr);
++- bVal = _mm_mul_ps(bVal, logarithm);
+++ // Now calculate b*lna
+++ bVal = _mm_loadu_ps(bPtr);
+++ bVal = _mm_mul_ps(bVal, logarithm);
++
++- // Now compute exp(b*lna)
++- bVal = _mm_max_ps(_mm_min_ps(bVal, exp_hi), exp_lo);
+++ // Now compute exp(b*lna)
+++ bVal = _mm_max_ps(_mm_min_ps(bVal, exp_hi), exp_lo);
++
++- fx = _mm_add_ps(_mm_mul_ps(bVal, log2EF), half);
+++ fx = _mm_add_ps(_mm_mul_ps(bVal, log2EF), half);
++
++- emm0 = _mm_cvttps_epi32(fx);
++- tmp = _mm_cvtepi32_ps(emm0);
+++ emm0 = _mm_cvttps_epi32(fx);
+++ tmp = _mm_cvtepi32_ps(emm0);
++
++- mask = _mm_and_ps(_mm_cmpgt_ps(tmp, fx), one);
++- fx = _mm_sub_ps(tmp, mask);
+++ mask = _mm_and_ps(_mm_cmpgt_ps(tmp, fx), one);
+++ fx = _mm_sub_ps(tmp, mask);
++
++- tmp = _mm_mul_ps(fx, exp_C1);
++- z = _mm_mul_ps(fx, exp_C2);
++- bVal = _mm_sub_ps(_mm_sub_ps(bVal, tmp), z);
++- z = _mm_mul_ps(bVal, bVal);
+++ tmp = _mm_mul_ps(fx, exp_C1);
+++ z = _mm_mul_ps(fx, exp_C2);
+++ bVal = _mm_sub_ps(_mm_sub_ps(bVal, tmp), z);
+++ z = _mm_mul_ps(bVal, bVal);
++
++- y = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(exp_p0, bVal), exp_p1), bVal);
++- y = _mm_add_ps(_mm_mul_ps(_mm_add_ps(y, exp_p2), bVal), exp_p3);
++- y = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(y, bVal), exp_p4), bVal);
++- y = _mm_add_ps(_mm_mul_ps(_mm_add_ps(y, exp_p5), z), bVal);
++- y = _mm_add_ps(y, one);
+++ y = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(exp_p0, bVal), exp_p1), bVal);
+++ y = _mm_add_ps(_mm_mul_ps(_mm_add_ps(y, exp_p2), bVal), exp_p3);
+++ y = _mm_mul_ps(_mm_add_ps(_mm_mul_ps(y, bVal), exp_p4), bVal);
+++ y = _mm_add_ps(_mm_mul_ps(_mm_add_ps(y, exp_p5), z), bVal);
+++ y = _mm_add_ps(y, one);
++
++- emm0 = _mm_slli_epi32(_mm_add_epi32(_mm_cvttps_epi32(fx), pi32_0x7f), 23);
+++ emm0 = _mm_slli_epi32(_mm_add_epi32(_mm_cvttps_epi32(fx), pi32_0x7f), 23);
++
++- pow2n = _mm_castsi128_ps(emm0);
++- cVal = _mm_mul_ps(y, pow2n);
+++ pow2n = _mm_castsi128_ps(emm0);
+++ cVal = _mm_mul_ps(y, pow2n);
++
++- _mm_storeu_ps(cPtr, cVal);
+++ _mm_storeu_ps(cPtr, cVal);
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *cPtr++ = powf(*aPtr++, *bPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = powf(*aPtr++, *bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for unaligned */
++@@ -577,100 +695,131 @@ volk_32f_x2_pow_32f_u_sse4_1(float* cVector, const float* bVector,
++ #include <immintrin.h>
++
++ #define POLY0_AVX2_FMA(x, c0) _mm256_set1_ps(c0)
++-#define POLY1_AVX2_FMA(x, c0, c1) _mm256_fmadd_ps(POLY0_AVX2_FMA(x, c1), x, _mm256_set1_ps(c0))
++-#define POLY2_AVX2_FMA(x, c0, c1, c2) _mm256_fmadd_ps(POLY1_AVX2_FMA(x, c1, c2), x, _mm256_set1_ps(c0))
++-#define POLY3_AVX2_FMA(x, c0, c1, c2, c3) _mm256_fmadd_ps(POLY2_AVX2_FMA(x, c1, c2, c3), x, _mm256_set1_ps(c0))
++-#define POLY4_AVX2_FMA(x, c0, c1, c2, c3, c4) _mm256_fmadd_ps(POLY3_AVX2_FMA(x, c1, c2, c3, c4), x, _mm256_set1_ps(c0))
++-#define POLY5_AVX2_FMA(x, c0, c1, c2, c3, c4, c5) _mm256_fmadd_ps(POLY4_AVX2_FMA(x, c1, c2, c3, c4, c5), x, _mm256_set1_ps(c0))
++-
++-static inline void
++-volk_32f_x2_pow_32f_u_avx2_fma(float* cVector, const float* bVector,
++- const float* aVector, unsigned int num_points)
+++#define POLY1_AVX2_FMA(x, c0, c1) \
+++ _mm256_fmadd_ps(POLY0_AVX2_FMA(x, c1), x, _mm256_set1_ps(c0))
+++#define POLY2_AVX2_FMA(x, c0, c1, c2) \
+++ _mm256_fmadd_ps(POLY1_AVX2_FMA(x, c1, c2), x, _mm256_set1_ps(c0))
+++#define POLY3_AVX2_FMA(x, c0, c1, c2, c3) \
+++ _mm256_fmadd_ps(POLY2_AVX2_FMA(x, c1, c2, c3), x, _mm256_set1_ps(c0))
+++#define POLY4_AVX2_FMA(x, c0, c1, c2, c3, c4) \
+++ _mm256_fmadd_ps(POLY3_AVX2_FMA(x, c1, c2, c3, c4), x, _mm256_set1_ps(c0))
+++#define POLY5_AVX2_FMA(x, c0, c1, c2, c3, c4, c5) \
+++ _mm256_fmadd_ps(POLY4_AVX2_FMA(x, c1, c2, c3, c4, c5), x, _mm256_set1_ps(c0))
+++
+++static inline void volk_32f_x2_pow_32f_u_avx2_fma(float* cVector,
+++ const float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- __m256 aVal, bVal, cVal, logarithm, mantissa, frac, leadingOne;
++- __m256 tmp, fx, mask, pow2n, z, y;
++- __m256 one, exp_hi, exp_lo, ln2, log2EF, half, exp_C1, exp_C2;
++- __m256 exp_p0, exp_p1, exp_p2, exp_p3, exp_p4, exp_p5;
++- __m256i bias, exp, emm0, pi32_0x7f;
++-
++- one = _mm256_set1_ps(1.0);
++- exp_hi = _mm256_set1_ps(88.3762626647949);
++- exp_lo = _mm256_set1_ps(-88.3762626647949);
++- ln2 = _mm256_set1_ps(0.6931471805);
++- log2EF = _mm256_set1_ps(1.44269504088896341);
++- half = _mm256_set1_ps(0.5);
++- exp_C1 = _mm256_set1_ps(0.693359375);
++- exp_C2 = _mm256_set1_ps(-2.12194440e-4);
++- pi32_0x7f = _mm256_set1_epi32(0x7f);
++-
++- exp_p0 = _mm256_set1_ps(1.9875691500e-4);
++- exp_p1 = _mm256_set1_ps(1.3981999507e-3);
++- exp_p2 = _mm256_set1_ps(8.3334519073e-3);
++- exp_p3 = _mm256_set1_ps(4.1665795894e-2);
++- exp_p4 = _mm256_set1_ps(1.6666665459e-1);
++- exp_p5 = _mm256_set1_ps(5.0000001201e-1);
++-
++- for(;number < eighthPoints; number++){
++- // First compute the logarithm
++- aVal = _mm256_loadu_ps(aPtr);
++- bias = _mm256_set1_epi32(127);
++- leadingOne = _mm256_set1_ps(1.0f);
++- exp = _mm256_sub_epi32(_mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal), _mm256_set1_epi32(0x7f800000)), 23), bias);
++- logarithm = _mm256_cvtepi32_ps(exp);
++-
++- frac = _mm256_or_ps(leadingOne, _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
+++ float* cPtr = cVector;
+++ const float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ __m256 aVal, bVal, cVal, logarithm, mantissa, frac, leadingOne;
+++ __m256 tmp, fx, mask, pow2n, z, y;
+++ __m256 one, exp_hi, exp_lo, ln2, log2EF, half, exp_C1, exp_C2;
+++ __m256 exp_p0, exp_p1, exp_p2, exp_p3, exp_p4, exp_p5;
+++ __m256i bias, exp, emm0, pi32_0x7f;
+++
+++ one = _mm256_set1_ps(1.0);
+++ exp_hi = _mm256_set1_ps(88.3762626647949);
+++ exp_lo = _mm256_set1_ps(-88.3762626647949);
+++ ln2 = _mm256_set1_ps(0.6931471805);
+++ log2EF = _mm256_set1_ps(1.44269504088896341);
+++ half = _mm256_set1_ps(0.5);
+++ exp_C1 = _mm256_set1_ps(0.693359375);
+++ exp_C2 = _mm256_set1_ps(-2.12194440e-4);
+++ pi32_0x7f = _mm256_set1_epi32(0x7f);
+++
+++ exp_p0 = _mm256_set1_ps(1.9875691500e-4);
+++ exp_p1 = _mm256_set1_ps(1.3981999507e-3);
+++ exp_p2 = _mm256_set1_ps(8.3334519073e-3);
+++ exp_p3 = _mm256_set1_ps(4.1665795894e-2);
+++ exp_p4 = _mm256_set1_ps(1.6666665459e-1);
+++ exp_p5 = _mm256_set1_ps(5.0000001201e-1);
+++
+++ for (; number < eighthPoints; number++) {
+++ // First compute the logarithm
+++ aVal = _mm256_loadu_ps(aPtr);
+++ bias = _mm256_set1_epi32(127);
+++ leadingOne = _mm256_set1_ps(1.0f);
+++ exp = _mm256_sub_epi32(
+++ _mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal),
+++ _mm256_set1_epi32(0x7f800000)),
+++ 23),
+++ bias);
+++ logarithm = _mm256_cvtepi32_ps(exp);
+++
+++ frac = _mm256_or_ps(
+++ leadingOne,
+++ _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
++
++ #if POW_POLY_DEGREE == 6
++- mantissa = POLY5_AVX2_FMA( frac, 3.1157899f, -3.3241990f, 2.5988452f, -1.2315303f, 3.1821337e-1f, -3.4436006e-2f);
+++ mantissa = POLY5_AVX2_FMA(frac,
+++ 3.1157899f,
+++ -3.3241990f,
+++ 2.5988452f,
+++ -1.2315303f,
+++ 3.1821337e-1f,
+++ -3.4436006e-2f);
++ #elif POW_POLY_DEGREE == 5
++- mantissa = POLY4_AVX2_FMA( frac, 2.8882704548164776201f, -2.52074962577807006663f, 1.48116647521213171641f, -0.465725644288844778798f, 0.0596515482674574969533f);
+++ mantissa = POLY4_AVX2_FMA(frac,
+++ 2.8882704548164776201f,
+++ -2.52074962577807006663f,
+++ 1.48116647521213171641f,
+++ -0.465725644288844778798f,
+++ 0.0596515482674574969533f);
++ #elif POW_POLY_DEGREE == 4
++- mantissa = POLY3_AVX2_FMA( frac, 2.61761038894603480148f, -1.75647175389045657003f, 0.688243882994381274313f, -0.107254423828329604454f);
+++ mantissa = POLY3_AVX2_FMA(frac,
+++ 2.61761038894603480148f,
+++ -1.75647175389045657003f,
+++ 0.688243882994381274313f,
+++ -0.107254423828329604454f);
++ #elif POW_POLY_DEGREE == 3
++- mantissa = POLY2_AVX2_FMA( frac, 2.28330284476918490682f, -1.04913055217340124191f, 0.204446009836232697516f);
+++ mantissa = POLY2_AVX2_FMA(frac,
+++ 2.28330284476918490682f,
+++ -1.04913055217340124191f,
+++ 0.204446009836232697516f);
++ #else
++ #error
++ #endif
++
++- logarithm = _mm256_fmadd_ps(mantissa, _mm256_sub_ps(frac, leadingOne), logarithm);
++- logarithm = _mm256_mul_ps(logarithm, ln2);
+++ logarithm = _mm256_fmadd_ps(mantissa, _mm256_sub_ps(frac, leadingOne), logarithm);
+++ logarithm = _mm256_mul_ps(logarithm, ln2);
++
++
++- // Now calculate b*lna
++- bVal = _mm256_loadu_ps(bPtr);
++- bVal = _mm256_mul_ps(bVal, logarithm);
+++ // Now calculate b*lna
+++ bVal = _mm256_loadu_ps(bPtr);
+++ bVal = _mm256_mul_ps(bVal, logarithm);
++
++- // Now compute exp(b*lna)
++- bVal = _mm256_max_ps(_mm256_min_ps(bVal, exp_hi), exp_lo);
+++ // Now compute exp(b*lna)
+++ bVal = _mm256_max_ps(_mm256_min_ps(bVal, exp_hi), exp_lo);
++
++- fx = _mm256_fmadd_ps(bVal, log2EF, half);
+++ fx = _mm256_fmadd_ps(bVal, log2EF, half);
++
++- emm0 = _mm256_cvttps_epi32(fx);
++- tmp = _mm256_cvtepi32_ps(emm0);
+++ emm0 = _mm256_cvttps_epi32(fx);
+++ tmp = _mm256_cvtepi32_ps(emm0);
++
++- mask = _mm256_and_ps(_mm256_cmp_ps(tmp, fx, _CMP_GT_OS), one);
++- fx = _mm256_sub_ps(tmp, mask);
+++ mask = _mm256_and_ps(_mm256_cmp_ps(tmp, fx, _CMP_GT_OS), one);
+++ fx = _mm256_sub_ps(tmp, mask);
++
++- tmp = _mm256_fnmadd_ps(fx, exp_C1, bVal);
++- bVal = _mm256_fnmadd_ps(fx, exp_C2, tmp);
++- z = _mm256_mul_ps(bVal, bVal);
+++ tmp = _mm256_fnmadd_ps(fx, exp_C1, bVal);
+++ bVal = _mm256_fnmadd_ps(fx, exp_C2, tmp);
+++ z = _mm256_mul_ps(bVal, bVal);
++
++- y = _mm256_fmadd_ps(exp_p0, bVal, exp_p1);
++- y = _mm256_fmadd_ps(y, bVal, exp_p2);
++- y = _mm256_fmadd_ps(y, bVal, exp_p3);
++- y = _mm256_fmadd_ps(y, bVal, exp_p4);
++- y = _mm256_fmadd_ps(y, bVal, exp_p5);
++- y = _mm256_fmadd_ps(y, z, bVal);
++- y = _mm256_add_ps(y, one);
+++ y = _mm256_fmadd_ps(exp_p0, bVal, exp_p1);
+++ y = _mm256_fmadd_ps(y, bVal, exp_p2);
+++ y = _mm256_fmadd_ps(y, bVal, exp_p3);
+++ y = _mm256_fmadd_ps(y, bVal, exp_p4);
+++ y = _mm256_fmadd_ps(y, bVal, exp_p5);
+++ y = _mm256_fmadd_ps(y, z, bVal);
+++ y = _mm256_add_ps(y, one);
++
++- emm0 = _mm256_slli_epi32(_mm256_add_epi32(_mm256_cvttps_epi32(fx), pi32_0x7f), 23);
+++ emm0 =
+++ _mm256_slli_epi32(_mm256_add_epi32(_mm256_cvttps_epi32(fx), pi32_0x7f), 23);
++
++ pow2n = _mm256_castsi256_ps(emm0);
++ cVal = _mm256_mul_ps(y, pow2n);
++@@ -680,12 +829,12 @@ volk_32f_x2_pow_32f_u_avx2_fma(float* cVector, const float* bVector,
++ aPtr += 8;
++ bPtr += 8;
++ cPtr += 8;
++- }
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = pow(*aPtr++, *bPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = pow(*aPtr++, *bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA for unaligned */
++@@ -694,99 +843,131 @@ volk_32f_x2_pow_32f_u_avx2_fma(float* cVector, const float* bVector,
++ #include <immintrin.h>
++
++ #define POLY0_AVX2(x, c0) _mm256_set1_ps(c0)
++-#define POLY1_AVX2(x, c0, c1) _mm256_add_ps(_mm256_mul_ps(POLY0_AVX2(x, c1), x), _mm256_set1_ps(c0))
++-#define POLY2_AVX2(x, c0, c1, c2) _mm256_add_ps(_mm256_mul_ps(POLY1_AVX2(x, c1, c2), x), _mm256_set1_ps(c0))
++-#define POLY3_AVX2(x, c0, c1, c2, c3) _mm256_add_ps(_mm256_mul_ps(POLY2_AVX2(x, c1, c2, c3), x), _mm256_set1_ps(c0))
++-#define POLY4_AVX2(x, c0, c1, c2, c3, c4) _mm256_add_ps(_mm256_mul_ps(POLY3_AVX2(x, c1, c2, c3, c4), x), _mm256_set1_ps(c0))
++-#define POLY5_AVX2(x, c0, c1, c2, c3, c4, c5) _mm256_add_ps(_mm256_mul_ps(POLY4_AVX2(x, c1, c2, c3, c4, c5), x), _mm256_set1_ps(c0))
++-
++-static inline void
++-volk_32f_x2_pow_32f_u_avx2(float* cVector, const float* bVector,
++- const float* aVector, unsigned int num_points)
+++#define POLY1_AVX2(x, c0, c1) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY0_AVX2(x, c1), x), _mm256_set1_ps(c0))
+++#define POLY2_AVX2(x, c0, c1, c2) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY1_AVX2(x, c1, c2), x), _mm256_set1_ps(c0))
+++#define POLY3_AVX2(x, c0, c1, c2, c3) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY2_AVX2(x, c1, c2, c3), x), _mm256_set1_ps(c0))
+++#define POLY4_AVX2(x, c0, c1, c2, c3, c4) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY3_AVX2(x, c1, c2, c3, c4), x), _mm256_set1_ps(c0))
+++#define POLY5_AVX2(x, c0, c1, c2, c3, c4, c5) \
+++ _mm256_add_ps(_mm256_mul_ps(POLY4_AVX2(x, c1, c2, c3, c4, c5), x), _mm256_set1_ps(c0))
+++
+++static inline void volk_32f_x2_pow_32f_u_avx2(float* cVector,
+++ const float* bVector,
+++ const float* aVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* bPtr = bVector;
++- const float* aPtr = aVector;
++-
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- __m256 aVal, bVal, cVal, logarithm, mantissa, frac, leadingOne;
++- __m256 tmp, fx, mask, pow2n, z, y;
++- __m256 one, exp_hi, exp_lo, ln2, log2EF, half, exp_C1, exp_C2;
++- __m256 exp_p0, exp_p1, exp_p2, exp_p3, exp_p4, exp_p5;
++- __m256i bias, exp, emm0, pi32_0x7f;
++-
++- one = _mm256_set1_ps(1.0);
++- exp_hi = _mm256_set1_ps(88.3762626647949);
++- exp_lo = _mm256_set1_ps(-88.3762626647949);
++- ln2 = _mm256_set1_ps(0.6931471805);
++- log2EF = _mm256_set1_ps(1.44269504088896341);
++- half = _mm256_set1_ps(0.5);
++- exp_C1 = _mm256_set1_ps(0.693359375);
++- exp_C2 = _mm256_set1_ps(-2.12194440e-4);
++- pi32_0x7f = _mm256_set1_epi32(0x7f);
++-
++- exp_p0 = _mm256_set1_ps(1.9875691500e-4);
++- exp_p1 = _mm256_set1_ps(1.3981999507e-3);
++- exp_p2 = _mm256_set1_ps(8.3334519073e-3);
++- exp_p3 = _mm256_set1_ps(4.1665795894e-2);
++- exp_p4 = _mm256_set1_ps(1.6666665459e-1);
++- exp_p5 = _mm256_set1_ps(5.0000001201e-1);
++-
++- for(;number < eighthPoints; number++){
++- // First compute the logarithm
++- aVal = _mm256_loadu_ps(aPtr);
++- bias = _mm256_set1_epi32(127);
++- leadingOne = _mm256_set1_ps(1.0f);
++- exp = _mm256_sub_epi32(_mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal), _mm256_set1_epi32(0x7f800000)), 23), bias);
++- logarithm = _mm256_cvtepi32_ps(exp);
++-
++- frac = _mm256_or_ps(leadingOne, _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
+++ float* cPtr = cVector;
+++ const float* bPtr = bVector;
+++ const float* aPtr = aVector;
+++
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ __m256 aVal, bVal, cVal, logarithm, mantissa, frac, leadingOne;
+++ __m256 tmp, fx, mask, pow2n, z, y;
+++ __m256 one, exp_hi, exp_lo, ln2, log2EF, half, exp_C1, exp_C2;
+++ __m256 exp_p0, exp_p1, exp_p2, exp_p3, exp_p4, exp_p5;
+++ __m256i bias, exp, emm0, pi32_0x7f;
+++
+++ one = _mm256_set1_ps(1.0);
+++ exp_hi = _mm256_set1_ps(88.3762626647949);
+++ exp_lo = _mm256_set1_ps(-88.3762626647949);
+++ ln2 = _mm256_set1_ps(0.6931471805);
+++ log2EF = _mm256_set1_ps(1.44269504088896341);
+++ half = _mm256_set1_ps(0.5);
+++ exp_C1 = _mm256_set1_ps(0.693359375);
+++ exp_C2 = _mm256_set1_ps(-2.12194440e-4);
+++ pi32_0x7f = _mm256_set1_epi32(0x7f);
+++
+++ exp_p0 = _mm256_set1_ps(1.9875691500e-4);
+++ exp_p1 = _mm256_set1_ps(1.3981999507e-3);
+++ exp_p2 = _mm256_set1_ps(8.3334519073e-3);
+++ exp_p3 = _mm256_set1_ps(4.1665795894e-2);
+++ exp_p4 = _mm256_set1_ps(1.6666665459e-1);
+++ exp_p5 = _mm256_set1_ps(5.0000001201e-1);
+++
+++ for (; number < eighthPoints; number++) {
+++ // First compute the logarithm
+++ aVal = _mm256_loadu_ps(aPtr);
+++ bias = _mm256_set1_epi32(127);
+++ leadingOne = _mm256_set1_ps(1.0f);
+++ exp = _mm256_sub_epi32(
+++ _mm256_srli_epi32(_mm256_and_si256(_mm256_castps_si256(aVal),
+++ _mm256_set1_epi32(0x7f800000)),
+++ 23),
+++ bias);
+++ logarithm = _mm256_cvtepi32_ps(exp);
+++
+++ frac = _mm256_or_ps(
+++ leadingOne,
+++ _mm256_and_ps(aVal, _mm256_castsi256_ps(_mm256_set1_epi32(0x7fffff))));
++
++ #if POW_POLY_DEGREE == 6
++- mantissa = POLY5_AVX2( frac, 3.1157899f, -3.3241990f, 2.5988452f, -1.2315303f, 3.1821337e-1f, -3.4436006e-2f);
+++ mantissa = POLY5_AVX2(frac,
+++ 3.1157899f,
+++ -3.3241990f,
+++ 2.5988452f,
+++ -1.2315303f,
+++ 3.1821337e-1f,
+++ -3.4436006e-2f);
++ #elif POW_POLY_DEGREE == 5
++- mantissa = POLY4_AVX2( frac, 2.8882704548164776201f, -2.52074962577807006663f, 1.48116647521213171641f, -0.465725644288844778798f, 0.0596515482674574969533f);
+++ mantissa = POLY4_AVX2(frac,
+++ 2.8882704548164776201f,
+++ -2.52074962577807006663f,
+++ 1.48116647521213171641f,
+++ -0.465725644288844778798f,
+++ 0.0596515482674574969533f);
++ #elif POW_POLY_DEGREE == 4
++- mantissa = POLY3_AVX2( frac, 2.61761038894603480148f, -1.75647175389045657003f, 0.688243882994381274313f, -0.107254423828329604454f);
+++ mantissa = POLY3_AVX2(frac,
+++ 2.61761038894603480148f,
+++ -1.75647175389045657003f,
+++ 0.688243882994381274313f,
+++ -0.107254423828329604454f);
++ #elif POW_POLY_DEGREE == 3
++- mantissa = POLY2_AVX2( frac, 2.28330284476918490682f, -1.04913055217340124191f, 0.204446009836232697516f);
+++ mantissa = POLY2_AVX2(frac,
+++ 2.28330284476918490682f,
+++ -1.04913055217340124191f,
+++ 0.204446009836232697516f);
++ #else
++ #error
++ #endif
++
++- logarithm = _mm256_add_ps(_mm256_mul_ps(mantissa, _mm256_sub_ps(frac, leadingOne)), logarithm);
++- logarithm = _mm256_mul_ps(logarithm, ln2);
+++ logarithm = _mm256_add_ps(
+++ _mm256_mul_ps(mantissa, _mm256_sub_ps(frac, leadingOne)), logarithm);
+++ logarithm = _mm256_mul_ps(logarithm, ln2);
++
++- // Now calculate b*lna
++- bVal = _mm256_loadu_ps(bPtr);
++- bVal = _mm256_mul_ps(bVal, logarithm);
+++ // Now calculate b*lna
+++ bVal = _mm256_loadu_ps(bPtr);
+++ bVal = _mm256_mul_ps(bVal, logarithm);
++
++- // Now compute exp(b*lna)
++- bVal = _mm256_max_ps(_mm256_min_ps(bVal, exp_hi), exp_lo);
+++ // Now compute exp(b*lna)
+++ bVal = _mm256_max_ps(_mm256_min_ps(bVal, exp_hi), exp_lo);
++
++- fx = _mm256_add_ps(_mm256_mul_ps(bVal, log2EF), half);
+++ fx = _mm256_add_ps(_mm256_mul_ps(bVal, log2EF), half);
++
++- emm0 = _mm256_cvttps_epi32(fx);
++- tmp = _mm256_cvtepi32_ps(emm0);
+++ emm0 = _mm256_cvttps_epi32(fx);
+++ tmp = _mm256_cvtepi32_ps(emm0);
++
++- mask = _mm256_and_ps(_mm256_cmp_ps(tmp, fx, _CMP_GT_OS), one);
++- fx = _mm256_sub_ps(tmp, mask);
+++ mask = _mm256_and_ps(_mm256_cmp_ps(tmp, fx, _CMP_GT_OS), one);
+++ fx = _mm256_sub_ps(tmp, mask);
++
++- tmp = _mm256_sub_ps(bVal, _mm256_mul_ps(fx, exp_C1));
++- bVal = _mm256_sub_ps(tmp, _mm256_mul_ps(fx, exp_C2));
++- z = _mm256_mul_ps(bVal, bVal);
+++ tmp = _mm256_sub_ps(bVal, _mm256_mul_ps(fx, exp_C1));
+++ bVal = _mm256_sub_ps(tmp, _mm256_mul_ps(fx, exp_C2));
+++ z = _mm256_mul_ps(bVal, bVal);
++
++- y = _mm256_add_ps(_mm256_mul_ps(exp_p0, bVal), exp_p1);
++- y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p2);
++- y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p3);
++- y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p4);
++- y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p5);
++- y = _mm256_add_ps(_mm256_mul_ps(y, z), bVal);
++- y = _mm256_add_ps(y, one);
+++ y = _mm256_add_ps(_mm256_mul_ps(exp_p0, bVal), exp_p1);
+++ y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p2);
+++ y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p3);
+++ y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p4);
+++ y = _mm256_add_ps(_mm256_mul_ps(y, bVal), exp_p5);
+++ y = _mm256_add_ps(_mm256_mul_ps(y, z), bVal);
+++ y = _mm256_add_ps(y, one);
++
++- emm0 = _mm256_slli_epi32(_mm256_add_epi32(_mm256_cvttps_epi32(fx), pi32_0x7f), 23);
+++ emm0 =
+++ _mm256_slli_epi32(_mm256_add_epi32(_mm256_cvttps_epi32(fx), pi32_0x7f), 23);
++
++ pow2n = _mm256_castsi256_ps(emm0);
++ cVal = _mm256_mul_ps(y, pow2n);
++@@ -796,12 +977,12 @@ volk_32f_x2_pow_32f_u_avx2(float* cVector, const float* bVector,
++ aPtr += 8;
++ bPtr += 8;
++ cPtr += 8;
++- }
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = pow(*aPtr++, *bPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = pow(*aPtr++, *bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 for unaligned */
++diff --git a/kernels/volk/volk_32f_x2_s32f_interleave_16ic.h b/kernels/volk/volk_32f_x2_s32f_interleave_16ic.h
++index 8021faf..04e5892 100644
++--- a/kernels/volk/volk_32f_x2_s32f_interleave_16ic.h
+++++ b/kernels/volk/volk_32f_x2_s32f_interleave_16ic.h
++@@ -32,8 +32,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_x2_s32f_interleave_16ic(lv_16sc_t* complexVector, const float* iBuffer, const float* qBuffer, const float scalar, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_x2_s32f_interleave_16ic(lv_16sc_t* complexVector, const float* iBuffer,
+++ * const float* qBuffer, const float scalar, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li iBuffer: Input vector of samples for the real part.
++@@ -75,60 +75,62 @@
++ #ifndef INCLUDED_volk_32f_x2_s32f_interleave_16ic_a_H
++ #define INCLUDED_volk_32f_x2_s32f_interleave_16ic_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_s32f_interleave_16ic_a_avx2(lv_16sc_t* complexVector, const float* iBuffer,
++- const float* qBuffer, const float scalar, unsigned int num_points)
+++static inline void volk_32f_x2_s32f_interleave_16ic_a_avx2(lv_16sc_t* complexVector,
+++ const float* iBuffer,
+++ const float* qBuffer,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const float* iBufferPtr = iBuffer;
++- const float* qBufferPtr = qBuffer;
+++ unsigned int number = 0;
+++ const float* iBufferPtr = iBuffer;
+++ const float* qBufferPtr = qBuffer;
++
++- __m256 vScalar = _mm256_set1_ps(scalar);
+++ __m256 vScalar = _mm256_set1_ps(scalar);
++
++- const unsigned int eighthPoints = num_points / 8;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- __m256 iValue, qValue, cplxValue1, cplxValue2;
++- __m256i intValue1, intValue2;
+++ __m256 iValue, qValue, cplxValue1, cplxValue2;
+++ __m256i intValue1, intValue2;
++
++- int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ int16_t* complexVectorPtr = (int16_t*)complexVector;
++
++- for(;number < eighthPoints; number++){
++- iValue = _mm256_load_ps(iBufferPtr);
++- qValue = _mm256_load_ps(qBufferPtr);
+++ for (; number < eighthPoints; number++) {
+++ iValue = _mm256_load_ps(iBufferPtr);
+++ qValue = _mm256_load_ps(qBufferPtr);
++
++- // Interleaves the lower two values in the i and q variables into one buffer
++- cplxValue1 = _mm256_unpacklo_ps(iValue, qValue);
++- cplxValue1 = _mm256_mul_ps(cplxValue1, vScalar);
+++ // Interleaves the lower two values in the i and q variables into one buffer
+++ cplxValue1 = _mm256_unpacklo_ps(iValue, qValue);
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, vScalar);
++
++- // Interleaves the upper two values in the i and q variables into one buffer
++- cplxValue2 = _mm256_unpackhi_ps(iValue, qValue);
++- cplxValue2 = _mm256_mul_ps(cplxValue2, vScalar);
+++ // Interleaves the upper two values in the i and q variables into one buffer
+++ cplxValue2 = _mm256_unpackhi_ps(iValue, qValue);
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, vScalar);
++
++- intValue1 = _mm256_cvtps_epi32(cplxValue1);
++- intValue2 = _mm256_cvtps_epi32(cplxValue2);
+++ intValue1 = _mm256_cvtps_epi32(cplxValue1);
+++ intValue2 = _mm256_cvtps_epi32(cplxValue2);
++
++- intValue1 = _mm256_packs_epi32(intValue1, intValue2);
+++ intValue1 = _mm256_packs_epi32(intValue1, intValue2);
++
++- _mm256_store_si256((__m256i*)complexVectorPtr, intValue1);
++- complexVectorPtr += 16;
+++ _mm256_store_si256((__m256i*)complexVectorPtr, intValue1);
+++ complexVectorPtr += 16;
++
++- iBufferPtr += 8;
++- qBufferPtr += 8;
++- }
+++ iBufferPtr += 8;
+++ qBufferPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- complexVectorPtr = (int16_t*)(&complexVector[number]);
++- for(; number < num_points; number++){
++- *complexVectorPtr++ = (int16_t)rintf(*iBufferPtr++ * scalar);
++- *complexVectorPtr++ = (int16_t)rintf(*qBufferPtr++ * scalar);
++- }
+++ number = eighthPoints * 8;
+++ complexVectorPtr = (int16_t*)(&complexVector[number]);
+++ for (; number < num_points; number++) {
+++ *complexVectorPtr++ = (int16_t)rintf(*iBufferPtr++ * scalar);
+++ *complexVectorPtr++ = (int16_t)rintf(*qBufferPtr++ * scalar);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -136,53 +138,55 @@ volk_32f_x2_s32f_interleave_16ic_a_avx2(lv_16sc_t* complexVector, const float* i
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32f_x2_s32f_interleave_16ic_a_sse2(lv_16sc_t* complexVector, const float* iBuffer,
++- const float* qBuffer, const float scalar, unsigned int num_points)
+++static inline void volk_32f_x2_s32f_interleave_16ic_a_sse2(lv_16sc_t* complexVector,
+++ const float* iBuffer,
+++ const float* qBuffer,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const float* iBufferPtr = iBuffer;
++- const float* qBufferPtr = qBuffer;
+++ unsigned int number = 0;
+++ const float* iBufferPtr = iBuffer;
+++ const float* qBufferPtr = qBuffer;
++
++- __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 vScalar = _mm_set_ps1(scalar);
++
++- const unsigned int quarterPoints = num_points / 4;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- __m128 iValue, qValue, cplxValue1, cplxValue2;
++- __m128i intValue1, intValue2;
+++ __m128 iValue, qValue, cplxValue1, cplxValue2;
+++ __m128i intValue1, intValue2;
++
++- int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ int16_t* complexVectorPtr = (int16_t*)complexVector;
++
++- for(;number < quarterPoints; number++){
++- iValue = _mm_load_ps(iBufferPtr);
++- qValue = _mm_load_ps(qBufferPtr);
+++ for (; number < quarterPoints; number++) {
+++ iValue = _mm_load_ps(iBufferPtr);
+++ qValue = _mm_load_ps(qBufferPtr);
++
++- // Interleaves the lower two values in the i and q variables into one buffer
++- cplxValue1 = _mm_unpacklo_ps(iValue, qValue);
++- cplxValue1 = _mm_mul_ps(cplxValue1, vScalar);
+++ // Interleaves the lower two values in the i and q variables into one buffer
+++ cplxValue1 = _mm_unpacklo_ps(iValue, qValue);
+++ cplxValue1 = _mm_mul_ps(cplxValue1, vScalar);
++
++- // Interleaves the upper two values in the i and q variables into one buffer
++- cplxValue2 = _mm_unpackhi_ps(iValue, qValue);
++- cplxValue2 = _mm_mul_ps(cplxValue2, vScalar);
+++ // Interleaves the upper two values in the i and q variables into one buffer
+++ cplxValue2 = _mm_unpackhi_ps(iValue, qValue);
+++ cplxValue2 = _mm_mul_ps(cplxValue2, vScalar);
++
++- intValue1 = _mm_cvtps_epi32(cplxValue1);
++- intValue2 = _mm_cvtps_epi32(cplxValue2);
+++ intValue1 = _mm_cvtps_epi32(cplxValue1);
+++ intValue2 = _mm_cvtps_epi32(cplxValue2);
++
++- intValue1 = _mm_packs_epi32(intValue1, intValue2);
+++ intValue1 = _mm_packs_epi32(intValue1, intValue2);
++
++- _mm_store_si128((__m128i*)complexVectorPtr, intValue1);
++- complexVectorPtr += 8;
+++ _mm_store_si128((__m128i*)complexVectorPtr, intValue1);
+++ complexVectorPtr += 8;
++
++- iBufferPtr += 4;
++- qBufferPtr += 4;
++- }
+++ iBufferPtr += 4;
+++ qBufferPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- complexVectorPtr = (int16_t*)(&complexVector[number]);
++- for(; number < num_points; number++){
++- *complexVectorPtr++ = (int16_t)rintf(*iBufferPtr++ * scalar);
++- *complexVectorPtr++ = (int16_t)rintf(*qBufferPtr++ * scalar);
++- }
+++ number = quarterPoints * 4;
+++ complexVectorPtr = (int16_t*)(&complexVector[number]);
+++ for (; number < num_points; number++) {
+++ *complexVectorPtr++ = (int16_t)rintf(*iBufferPtr++ * scalar);
+++ *complexVectorPtr++ = (int16_t)rintf(*qBufferPtr++ * scalar);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++@@ -190,79 +194,83 @@ volk_32f_x2_s32f_interleave_16ic_a_sse2(lv_16sc_t* complexVector, const float* i
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_x2_s32f_interleave_16ic_a_sse(lv_16sc_t* complexVector, const float* iBuffer,
++- const float* qBuffer, const float scalar, unsigned int num_points)
+++static inline void volk_32f_x2_s32f_interleave_16ic_a_sse(lv_16sc_t* complexVector,
+++ const float* iBuffer,
+++ const float* qBuffer,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const float* iBufferPtr = iBuffer;
++- const float* qBufferPtr = qBuffer;
+++ unsigned int number = 0;
+++ const float* iBufferPtr = iBuffer;
+++ const float* qBufferPtr = qBuffer;
++
++- __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 vScalar = _mm_set_ps1(scalar);
++
++- const unsigned int quarterPoints = num_points / 4;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- __m128 iValue, qValue, cplxValue;
+++ __m128 iValue, qValue, cplxValue;
++
++- int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ int16_t* complexVectorPtr = (int16_t*)complexVector;
++
++- __VOLK_ATTR_ALIGNED(16) float floatBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float floatBuffer[4];
++
++- for(;number < quarterPoints; number++){
++- iValue = _mm_load_ps(iBufferPtr);
++- qValue = _mm_load_ps(qBufferPtr);
+++ for (; number < quarterPoints; number++) {
+++ iValue = _mm_load_ps(iBufferPtr);
+++ qValue = _mm_load_ps(qBufferPtr);
++
++- // Interleaves the lower two values in the i and q variables into one buffer
++- cplxValue = _mm_unpacklo_ps(iValue, qValue);
++- cplxValue = _mm_mul_ps(cplxValue, vScalar);
+++ // Interleaves the lower two values in the i and q variables into one buffer
+++ cplxValue = _mm_unpacklo_ps(iValue, qValue);
+++ cplxValue = _mm_mul_ps(cplxValue, vScalar);
++
++- _mm_store_ps(floatBuffer, cplxValue);
+++ _mm_store_ps(floatBuffer, cplxValue);
++
++- *complexVectorPtr++ = (int16_t)rintf(floatBuffer[0]);
++- *complexVectorPtr++ = (int16_t)rintf(floatBuffer[1]);
++- *complexVectorPtr++ = (int16_t)rintf(floatBuffer[2]);
++- *complexVectorPtr++ = (int16_t)rintf(floatBuffer[3]);
+++ *complexVectorPtr++ = (int16_t)rintf(floatBuffer[0]);
+++ *complexVectorPtr++ = (int16_t)rintf(floatBuffer[1]);
+++ *complexVectorPtr++ = (int16_t)rintf(floatBuffer[2]);
+++ *complexVectorPtr++ = (int16_t)rintf(floatBuffer[3]);
++
++- // Interleaves the upper two values in the i and q variables into one buffer
++- cplxValue = _mm_unpackhi_ps(iValue, qValue);
++- cplxValue = _mm_mul_ps(cplxValue, vScalar);
+++ // Interleaves the upper two values in the i and q variables into one buffer
+++ cplxValue = _mm_unpackhi_ps(iValue, qValue);
+++ cplxValue = _mm_mul_ps(cplxValue, vScalar);
++
++- _mm_store_ps(floatBuffer, cplxValue);
+++ _mm_store_ps(floatBuffer, cplxValue);
++
++- *complexVectorPtr++ = (int16_t)rintf(floatBuffer[0]);
++- *complexVectorPtr++ = (int16_t)rintf(floatBuffer[1]);
++- *complexVectorPtr++ = (int16_t)rintf(floatBuffer[2]);
++- *complexVectorPtr++ = (int16_t)rintf(floatBuffer[3]);
+++ *complexVectorPtr++ = (int16_t)rintf(floatBuffer[0]);
+++ *complexVectorPtr++ = (int16_t)rintf(floatBuffer[1]);
+++ *complexVectorPtr++ = (int16_t)rintf(floatBuffer[2]);
+++ *complexVectorPtr++ = (int16_t)rintf(floatBuffer[3]);
++
++- iBufferPtr += 4;
++- qBufferPtr += 4;
++- }
+++ iBufferPtr += 4;
+++ qBufferPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- complexVectorPtr = (int16_t*)(&complexVector[number]);
++- for(; number < num_points; number++){
++- *complexVectorPtr++ = (int16_t)rintf(*iBufferPtr++ * scalar);
++- *complexVectorPtr++ = (int16_t)rintf(*qBufferPtr++ * scalar);
++- }
+++ number = quarterPoints * 4;
+++ complexVectorPtr = (int16_t*)(&complexVector[number]);
+++ for (; number < num_points; number++) {
+++ *complexVectorPtr++ = (int16_t)rintf(*iBufferPtr++ * scalar);
+++ *complexVectorPtr++ = (int16_t)rintf(*qBufferPtr++ * scalar);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_x2_s32f_interleave_16ic_generic(lv_16sc_t* complexVector, const float* iBuffer,
++- const float* qBuffer, const float scalar, unsigned int num_points)
+++static inline void volk_32f_x2_s32f_interleave_16ic_generic(lv_16sc_t* complexVector,
+++ const float* iBuffer,
+++ const float* qBuffer,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- int16_t* complexVectorPtr = (int16_t*)complexVector;
++- const float* iBufferPtr = iBuffer;
++- const float* qBufferPtr = qBuffer;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *complexVectorPtr++ = (int16_t)rintf(*iBufferPtr++ * scalar);
++- *complexVectorPtr++ = (int16_t)rintf(*qBufferPtr++ * scalar);
++- }
+++ int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ const float* iBufferPtr = iBuffer;
+++ const float* qBufferPtr = qBuffer;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *complexVectorPtr++ = (int16_t)rintf(*iBufferPtr++ * scalar);
+++ *complexVectorPtr++ = (int16_t)rintf(*qBufferPtr++ * scalar);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -272,60 +280,62 @@ volk_32f_x2_s32f_interleave_16ic_generic(lv_16sc_t* complexVector, const float*
++ #ifndef INCLUDED_volk_32f_x2_s32f_interleave_16ic_u_H
++ #define INCLUDED_volk_32f_x2_s32f_interleave_16ic_u_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_s32f_interleave_16ic_u_avx2(lv_16sc_t* complexVector, const float* iBuffer,
++- const float* qBuffer, const float scalar, unsigned int num_points)
+++static inline void volk_32f_x2_s32f_interleave_16ic_u_avx2(lv_16sc_t* complexVector,
+++ const float* iBuffer,
+++ const float* qBuffer,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const float* iBufferPtr = iBuffer;
++- const float* qBufferPtr = qBuffer;
+++ unsigned int number = 0;
+++ const float* iBufferPtr = iBuffer;
+++ const float* qBufferPtr = qBuffer;
++
++- __m256 vScalar = _mm256_set1_ps(scalar);
+++ __m256 vScalar = _mm256_set1_ps(scalar);
++
++- const unsigned int eighthPoints = num_points / 8;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- __m256 iValue, qValue, cplxValue1, cplxValue2;
++- __m256i intValue1, intValue2;
+++ __m256 iValue, qValue, cplxValue1, cplxValue2;
+++ __m256i intValue1, intValue2;
++
++- int16_t* complexVectorPtr = (int16_t*)complexVector;
+++ int16_t* complexVectorPtr = (int16_t*)complexVector;
++
++- for(;number < eighthPoints; number++){
++- iValue = _mm256_loadu_ps(iBufferPtr);
++- qValue = _mm256_loadu_ps(qBufferPtr);
+++ for (; number < eighthPoints; number++) {
+++ iValue = _mm256_loadu_ps(iBufferPtr);
+++ qValue = _mm256_loadu_ps(qBufferPtr);
++
++- // Interleaves the lower two values in the i and q variables into one buffer
++- cplxValue1 = _mm256_unpacklo_ps(iValue, qValue);
++- cplxValue1 = _mm256_mul_ps(cplxValue1, vScalar);
+++ // Interleaves the lower two values in the i and q variables into one buffer
+++ cplxValue1 = _mm256_unpacklo_ps(iValue, qValue);
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, vScalar);
++
++- // Interleaves the upper two values in the i and q variables into one buffer
++- cplxValue2 = _mm256_unpackhi_ps(iValue, qValue);
++- cplxValue2 = _mm256_mul_ps(cplxValue2, vScalar);
+++ // Interleaves the upper two values in the i and q variables into one buffer
+++ cplxValue2 = _mm256_unpackhi_ps(iValue, qValue);
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, vScalar);
++
++- intValue1 = _mm256_cvtps_epi32(cplxValue1);
++- intValue2 = _mm256_cvtps_epi32(cplxValue2);
+++ intValue1 = _mm256_cvtps_epi32(cplxValue1);
+++ intValue2 = _mm256_cvtps_epi32(cplxValue2);
++
++- intValue1 = _mm256_packs_epi32(intValue1, intValue2);
+++ intValue1 = _mm256_packs_epi32(intValue1, intValue2);
++
++- _mm256_storeu_si256((__m256i*)complexVectorPtr, intValue1);
++- complexVectorPtr += 16;
+++ _mm256_storeu_si256((__m256i*)complexVectorPtr, intValue1);
+++ complexVectorPtr += 16;
++
++- iBufferPtr += 8;
++- qBufferPtr += 8;
++- }
+++ iBufferPtr += 8;
+++ qBufferPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- complexVectorPtr = (int16_t*)(&complexVector[number]);
++- for(; number < num_points; number++){
++- *complexVectorPtr++ = (int16_t)rintf(*iBufferPtr++ * scalar);
++- *complexVectorPtr++ = (int16_t)rintf(*qBufferPtr++ * scalar);
++- }
+++ number = eighthPoints * 8;
+++ complexVectorPtr = (int16_t*)(&complexVector[number]);
+++ for (; number < num_points; number++) {
+++ *complexVectorPtr++ = (int16_t)rintf(*iBufferPtr++ * scalar);
+++ *complexVectorPtr++ = (int16_t)rintf(*qBufferPtr++ * scalar);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_32f_x2_subtract_32f.h b/kernels/volk/volk_32f_x2_subtract_32f.h
++index bdfa0a1..359974c 100644
++--- a/kernels/volk/volk_32f_x2_subtract_32f.h
+++++ b/kernels/volk/volk_32f_x2_subtract_32f.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_x2_subtract_32f(float* cVector, const float* aVector, const float* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_x2_subtract_32f(float* cVector, const float* aVector, const float*
+++ * bVector, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: The initial vector.
++@@ -77,126 +77,130 @@
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_subtract_32f_a_avx512f(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_subtract_32f_a_avx512f(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr = bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m512 aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
+++ __m512 aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
++
++- aVal = _mm512_load_ps(aPtr);
++- bVal = _mm512_load_ps(bPtr);
+++ aVal = _mm512_load_ps(aPtr);
+++ bVal = _mm512_load_ps(bPtr);
++
++- cVal = _mm512_sub_ps(aVal, bVal);
+++ cVal = _mm512_sub_ps(aVal, bVal);
++
++- _mm512_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm512_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints *16;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) - (*bPtr++);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) - (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_subtract_32f_a_avx(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_subtract_32f_a_avx(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr = bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m256 aVal, bVal, cVal;
++- for(;number < eighthPoints; number++){
+++ __m256 aVal, bVal, cVal;
+++ for (; number < eighthPoints; number++) {
++
++- aVal = _mm256_load_ps(aPtr);
++- bVal = _mm256_load_ps(bPtr);
+++ aVal = _mm256_load_ps(aPtr);
+++ bVal = _mm256_load_ps(bPtr);
++
++- cVal = _mm256_sub_ps(aVal, bVal);
+++ cVal = _mm256_sub_ps(aVal, bVal);
++
++- _mm256_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) - (*bPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) - (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32f_x2_subtract_32f_a_sse(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_subtract_32f_a_sse(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr = bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m128 aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
+++ __m128 aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm_load_ps(aPtr);
++- bVal = _mm_load_ps(bPtr);
+++ aVal = _mm_load_ps(aPtr);
+++ bVal = _mm_load_ps(bPtr);
++
++- cVal = _mm_sub_ps(aVal, bVal);
+++ cVal = _mm_sub_ps(aVal, bVal);
++
++- _mm_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) - (*bPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) - (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_x2_subtract_32f_generic(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_subtract_32f_generic(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr = bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) - (*bPtr++);
++- }
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) - (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -204,45 +208,48 @@ volk_32f_x2_subtract_32f_generic(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32f_x2_subtract_32f_neon(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_subtract_32f_neon(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr = bVector;
++- unsigned int number = 0;
++- unsigned int quarter_points = num_points / 4;
++-
++- float32x4_t a_vec, b_vec, c_vec;
++-
++- for(number = 0; number < quarter_points; number++){
++- a_vec = vld1q_f32(aPtr);
++- b_vec = vld1q_f32(bPtr);
++- c_vec = vsubq_f32(a_vec, b_vec);
++- vst1q_f32(cPtr, c_vec);
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
++-
++- for(number = quarter_points * 4; number < num_points; number++){
++- *cPtr++ = (*aPtr++) - (*bPtr++);
++- }
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++ unsigned int quarter_points = num_points / 4;
+++
+++ float32x4_t a_vec, b_vec, c_vec;
+++
+++ for (number = 0; number < quarter_points; number++) {
+++ a_vec = vld1q_f32(aPtr);
+++ b_vec = vld1q_f32(bPtr);
+++ c_vec = vsubq_f32(a_vec, b_vec);
+++ vst1q_f32(cPtr, c_vec);
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) - (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_ORC
++-extern void
++-volk_32f_x2_subtract_32f_a_orc_impl(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points);
++-
++-static inline void
++-volk_32f_x2_subtract_32f_u_orc(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++extern void volk_32f_x2_subtract_32f_a_orc_impl(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points);
+++
+++static inline void volk_32f_x2_subtract_32f_u_orc(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- volk_32f_x2_subtract_32f_a_orc_impl(cVector, aVector, bVector, num_points);
+++ volk_32f_x2_subtract_32f_a_orc_impl(cVector, aVector, bVector, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++@@ -259,36 +266,37 @@ volk_32f_x2_subtract_32f_u_orc(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_subtract_32f_u_avx512f(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_subtract_32f_u_avx512f(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr = bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m512 aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
+++ __m512 aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
++
++- aVal = _mm512_loadu_ps(aPtr);
++- bVal = _mm512_loadu_ps(bPtr);
+++ aVal = _mm512_loadu_ps(aPtr);
+++ bVal = _mm512_loadu_ps(bPtr);
++
++- cVal = _mm512_sub_ps(aVal, bVal);
+++ cVal = _mm512_sub_ps(aVal, bVal);
++
++- _mm512_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm512_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints *16;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) - (*bPtr++);
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) - (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++@@ -296,36 +304,37 @@ volk_32f_x2_subtract_32f_u_avx512f(float* cVector, const float* aVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32f_x2_subtract_32f_u_avx(float* cVector, const float* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32f_x2_subtract_32f_u_avx(float* cVector,
+++ const float* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- float* cPtr = cVector;
++- const float* aPtr = aVector;
++- const float* bPtr = bVector;
+++ float* cPtr = cVector;
+++ const float* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m256 aVal, bVal, cVal;
++- for(;number < eighthPoints; number++){
+++ __m256 aVal, bVal, cVal;
+++ for (; number < eighthPoints; number++) {
++
++- aVal = _mm256_loadu_ps(aPtr);
++- bVal = _mm256_loadu_ps(bPtr);
+++ aVal = _mm256_loadu_ps(aPtr);
+++ bVal = _mm256_loadu_ps(bPtr);
++
++- cVal = _mm256_sub_ps(aVal, bVal);
+++ cVal = _mm256_sub_ps(aVal, bVal);
++
++- _mm256_storeu_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm256_storeu_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) - (*bPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) - (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++diff --git a/kernels/volk/volk_32f_x3_sum_of_poly_32f.h b/kernels/volk/volk_32f_x3_sum_of_poly_32f.h
++index e74a385..b0b1466 100644
++--- a/kernels/volk/volk_32f_x3_sum_of_poly_32f.h
+++++ b/kernels/volk/volk_32f_x3_sum_of_poly_32f.h
++@@ -30,12 +30,13 @@
++ * multiply by the rectangle/bin width.
++ *
++ * Expressed as a formula, this function calculates
++- * \f$ \sum f(x) = \sum (c_0 + c_1 \cdot x + c_2 \cdot x^2 + c_3 \cdot x^3 + c_4 \cdot x^4)\f$
+++ * \f$ \sum f(x) = \sum (c_0 + c_1 \cdot x + c_2 \cdot x^2 + c_3 \cdot x^3 + c_4 \cdot
+++ * x^4)\f$
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32f_x3_sum_of_poly_32f(float* target, float* src0, float* center_point_array, float* cutoff, unsigned int num_points)
++- * \endcode
+++ * void volk_32f_x3_sum_of_poly_32f(float* target, float* src0, float* center_point_array,
+++ * float* cutoff, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li src0: x values
++@@ -53,9 +54,10 @@
++ * \code
++ * int npoints = 4096;
++ * float* coefficients = (float*)volk_malloc(sizeof(float) * 5, volk_get_alignment());
++- * float* input = (float*)volk_malloc(sizeof(float) * npoints, volk_get_alignment());
++- * float* result = (float*)volk_malloc(sizeof(float), volk_get_alignment());
++- * float* cutoff = (float*)volk_malloc(sizeof(float), volk_get_alignment());
+++ * float* input = (float*)volk_malloc(sizeof(float) * npoints,
+++ * volk_get_alignment()); float* result = (float*)volk_malloc(sizeof(float),
+++ * volk_get_alignment()); float* cutoff = (float*)volk_malloc(sizeof(float),
+++ * volk_get_alignment());
++ * // load precomputed Taylor series coefficients
++ * coefficients[0] = 4.48168907033806f; // c1
++ * coefficients[1] = coefficients[0] * 0.5f; // c2
++@@ -82,288 +84,291 @@
++ #ifndef INCLUDED_volk_32f_x3_sum_of_poly_32f_a_H
++ #define INCLUDED_volk_32f_x3_sum_of_poly_32f_a_H
++
++-#include<inttypes.h>
++-#include<stdio.h>
++-#include<volk/volk_complex.h>
+++#include <inttypes.h>
+++#include <stdio.h>
+++#include <volk/volk_complex.h>
++
++ #ifndef MAX
++-#define MAX(X,Y) ((X) > (Y)?(X):(Y))
+++#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
++ #endif
++
++ #ifdef LV_HAVE_SSE3
++-#include<xmmintrin.h>
++-#include<pmmintrin.h>
++-
++-static inline void
++-volk_32f_x3_sum_of_poly_32f_a_sse3(float* target, float* src0, float* center_point_array,
++- float* cutoff, unsigned int num_points)
+++#include <pmmintrin.h>
+++#include <xmmintrin.h>
+++
+++static inline void volk_32f_x3_sum_of_poly_32f_a_sse3(float* target,
+++ float* src0,
+++ float* center_point_array,
+++ float* cutoff,
+++ unsigned int num_points)
++ {
++- float result = 0.0f;
++- float fst = 0.0f;
++- float sq = 0.0f;
++- float thrd = 0.0f;
++- float frth = 0.0f;
++-
++- __m128 xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10;
++-
++- xmm9 = _mm_setzero_ps();
++- xmm1 = _mm_setzero_ps();
++- xmm0 = _mm_load1_ps(¢er_point_array[0]);
++- xmm6 = _mm_load1_ps(¢er_point_array[1]);
++- xmm7 = _mm_load1_ps(¢er_point_array[2]);
++- xmm8 = _mm_load1_ps(¢er_point_array[3]);
++- xmm10 = _mm_load1_ps(cutoff);
++-
++- int bound = num_points/8;
++- int leftovers = num_points - 8*bound;
++- int i = 0;
++- for(; i < bound; ++i) {
++- // 1st
++- xmm2 = _mm_load_ps(src0);
++- xmm2 = _mm_max_ps(xmm10, xmm2);
++- xmm3 = _mm_mul_ps(xmm2, xmm2);
++- xmm4 = _mm_mul_ps(xmm2, xmm3);
++- xmm5 = _mm_mul_ps(xmm3, xmm3);
++-
++- xmm2 = _mm_mul_ps(xmm2, xmm0);
++- xmm3 = _mm_mul_ps(xmm3, xmm6);
++- xmm4 = _mm_mul_ps(xmm4, xmm7);
++- xmm5 = _mm_mul_ps(xmm5, xmm8);
++-
++- xmm2 = _mm_add_ps(xmm2, xmm3);
++- xmm3 = _mm_add_ps(xmm4, xmm5);
++-
++- src0 += 4;
++-
++- xmm9 = _mm_add_ps(xmm2, xmm9);
++- xmm9 = _mm_add_ps(xmm3, xmm9);
++-
++- // 2nd
++- xmm2 = _mm_load_ps(src0);
++- xmm2 = _mm_max_ps(xmm10, xmm2);
++- xmm3 = _mm_mul_ps(xmm2, xmm2);
++- xmm4 = _mm_mul_ps(xmm2, xmm3);
++- xmm5 = _mm_mul_ps(xmm3, xmm3);
++-
++- xmm2 = _mm_mul_ps(xmm2, xmm0);
++- xmm3 = _mm_mul_ps(xmm3, xmm6);
++- xmm4 = _mm_mul_ps(xmm4, xmm7);
++- xmm5 = _mm_mul_ps(xmm5, xmm8);
++-
++- xmm2 = _mm_add_ps(xmm2, xmm3);
++- xmm3 = _mm_add_ps(xmm4, xmm5);
++-
++- src0 += 4;
++-
++- xmm1 = _mm_add_ps(xmm2, xmm1);
++- xmm1 = _mm_add_ps(xmm3, xmm1);
++- }
++- xmm2 = _mm_hadd_ps(xmm9, xmm1);
++- xmm3 = _mm_hadd_ps(xmm2, xmm2);
++- xmm4 = _mm_hadd_ps(xmm3, xmm3);
++- _mm_store_ss(&result, xmm4);
++-
++- for(i = 0; i < leftovers; ++i) {
++- fst = *src0++;
++- fst = MAX(fst, *cutoff);
++- sq = fst * fst;
++- thrd = fst * sq;
++- frth = sq * sq;
++- result += (center_point_array[0] * fst +
++- center_point_array[1] * sq +
++- center_point_array[2] * thrd +
++- center_point_array[3] * frth);
++- }
++-
++- result += (float)(num_points) * center_point_array[4];
++- *target = result;
+++ float result = 0.0f;
+++ float fst = 0.0f;
+++ float sq = 0.0f;
+++ float thrd = 0.0f;
+++ float frth = 0.0f;
+++
+++ __m128 xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10;
+++
+++ xmm9 = _mm_setzero_ps();
+++ xmm1 = _mm_setzero_ps();
+++ xmm0 = _mm_load1_ps(¢er_point_array[0]);
+++ xmm6 = _mm_load1_ps(¢er_point_array[1]);
+++ xmm7 = _mm_load1_ps(¢er_point_array[2]);
+++ xmm8 = _mm_load1_ps(¢er_point_array[3]);
+++ xmm10 = _mm_load1_ps(cutoff);
+++
+++ int bound = num_points / 8;
+++ int leftovers = num_points - 8 * bound;
+++ int i = 0;
+++ for (; i < bound; ++i) {
+++ // 1st
+++ xmm2 = _mm_load_ps(src0);
+++ xmm2 = _mm_max_ps(xmm10, xmm2);
+++ xmm3 = _mm_mul_ps(xmm2, xmm2);
+++ xmm4 = _mm_mul_ps(xmm2, xmm3);
+++ xmm5 = _mm_mul_ps(xmm3, xmm3);
+++
+++ xmm2 = _mm_mul_ps(xmm2, xmm0);
+++ xmm3 = _mm_mul_ps(xmm3, xmm6);
+++ xmm4 = _mm_mul_ps(xmm4, xmm7);
+++ xmm5 = _mm_mul_ps(xmm5, xmm8);
+++
+++ xmm2 = _mm_add_ps(xmm2, xmm3);
+++ xmm3 = _mm_add_ps(xmm4, xmm5);
+++
+++ src0 += 4;
+++
+++ xmm9 = _mm_add_ps(xmm2, xmm9);
+++ xmm9 = _mm_add_ps(xmm3, xmm9);
+++
+++ // 2nd
+++ xmm2 = _mm_load_ps(src0);
+++ xmm2 = _mm_max_ps(xmm10, xmm2);
+++ xmm3 = _mm_mul_ps(xmm2, xmm2);
+++ xmm4 = _mm_mul_ps(xmm2, xmm3);
+++ xmm5 = _mm_mul_ps(xmm3, xmm3);
+++
+++ xmm2 = _mm_mul_ps(xmm2, xmm0);
+++ xmm3 = _mm_mul_ps(xmm3, xmm6);
+++ xmm4 = _mm_mul_ps(xmm4, xmm7);
+++ xmm5 = _mm_mul_ps(xmm5, xmm8);
+++
+++ xmm2 = _mm_add_ps(xmm2, xmm3);
+++ xmm3 = _mm_add_ps(xmm4, xmm5);
+++
+++ src0 += 4;
+++
+++ xmm1 = _mm_add_ps(xmm2, xmm1);
+++ xmm1 = _mm_add_ps(xmm3, xmm1);
+++ }
+++ xmm2 = _mm_hadd_ps(xmm9, xmm1);
+++ xmm3 = _mm_hadd_ps(xmm2, xmm2);
+++ xmm4 = _mm_hadd_ps(xmm3, xmm3);
+++ _mm_store_ss(&result, xmm4);
+++
+++ for (i = 0; i < leftovers; ++i) {
+++ fst = *src0++;
+++ fst = MAX(fst, *cutoff);
+++ sq = fst * fst;
+++ thrd = fst * sq;
+++ frth = sq * sq;
+++ result += (center_point_array[0] * fst + center_point_array[1] * sq +
+++ center_point_array[2] * thrd + center_point_array[3] * frth);
+++ }
+++
+++ result += (float)(num_points)*center_point_array[4];
+++ *target = result;
++ }
++
++
++ #endif /*LV_HAVE_SSE3*/
++
++ #if LV_HAVE_AVX && LV_HAVE_FMA
++-#include<immintrin.h>
+++#include <immintrin.h>
++
++-static inline void
++-volk_32f_x3_sum_of_poly_32f_a_avx2_fma(float* target, float* src0, float* center_point_array,
++- float* cutoff, unsigned int num_points)
+++static inline void volk_32f_x3_sum_of_poly_32f_a_avx2_fma(float* target,
+++ float* src0,
+++ float* center_point_array,
+++ float* cutoff,
+++ unsigned int num_points)
++ {
++- const unsigned int eighth_points = num_points / 8;
++- float fst = 0.0;
++- float sq = 0.0;
++- float thrd = 0.0;
++- float frth = 0.0;
++-
++- __m256 cpa0, cpa1, cpa2, cpa3, cutoff_vec;
++- __m256 target_vec;
++- __m256 x_to_1, x_to_2, x_to_3, x_to_4;
++-
++- cpa0 = _mm256_set1_ps(center_point_array[0]);
++- cpa1 = _mm256_set1_ps(center_point_array[1]);
++- cpa2 = _mm256_set1_ps(center_point_array[2]);
++- cpa3 = _mm256_set1_ps(center_point_array[3]);
++- cutoff_vec = _mm256_set1_ps(*cutoff);
++- target_vec = _mm256_setzero_ps();
++-
++- unsigned int i;
++-
++- for(i = 0; i < eighth_points; ++i) {
++- x_to_1 = _mm256_load_ps(src0);
++- x_to_1 = _mm256_max_ps(x_to_1, cutoff_vec);
++- x_to_2 = _mm256_mul_ps(x_to_1, x_to_1); // x^2
++- x_to_3 = _mm256_mul_ps(x_to_1, x_to_2); // x^3
++- // x^1 * x^3 is slightly faster than x^2 * x^2
++- x_to_4 = _mm256_mul_ps(x_to_1, x_to_3); // x^4
++-
++- x_to_2 = _mm256_mul_ps(x_to_2, cpa1); // cpa[1] * x^2
++- x_to_4 = _mm256_mul_ps(x_to_4, cpa3); // cpa[3] * x^4
++-
++- x_to_1 = _mm256_fmadd_ps(x_to_1, cpa0, x_to_2);
++- x_to_3 = _mm256_fmadd_ps(x_to_3, cpa2, x_to_4);
++- // this is slightly faster than result += (x_to_1 + x_to_3)
++- target_vec = _mm256_add_ps(x_to_1, target_vec);
++- target_vec = _mm256_add_ps(x_to_3, target_vec);
++-
++- src0 += 8;
++- }
++-
++- // the hadd for vector reduction has very very slight impact @ 50k iters
++- __VOLK_ATTR_ALIGNED(32) float temp_results[8];
++- target_vec = _mm256_hadd_ps(target_vec, target_vec); // x0+x1 | x2+x3 | x0+x1 | x2+x3 || x4+x5 | x6+x7 | x4+x5 | x6+x7
++- _mm256_store_ps(temp_results, target_vec);
++- *target = temp_results[0] + temp_results[1] + temp_results[4] + temp_results[5];
++-
++- for(i = eighth_points*8; i < num_points; ++i) {
++- fst = *src0++;
++- fst = MAX(fst, *cutoff);
++- sq = fst * fst;
++- thrd = fst * sq;
++- frth = sq * sq;
++- *target += (center_point_array[0] * fst +
++- center_point_array[1] * sq +
++- center_point_array[2] * thrd +
++- center_point_array[3] * frth);
++- }
++- *target += (float)(num_points) * center_point_array[4];
+++ const unsigned int eighth_points = num_points / 8;
+++ float fst = 0.0;
+++ float sq = 0.0;
+++ float thrd = 0.0;
+++ float frth = 0.0;
+++
+++ __m256 cpa0, cpa1, cpa2, cpa3, cutoff_vec;
+++ __m256 target_vec;
+++ __m256 x_to_1, x_to_2, x_to_3, x_to_4;
+++
+++ cpa0 = _mm256_set1_ps(center_point_array[0]);
+++ cpa1 = _mm256_set1_ps(center_point_array[1]);
+++ cpa2 = _mm256_set1_ps(center_point_array[2]);
+++ cpa3 = _mm256_set1_ps(center_point_array[3]);
+++ cutoff_vec = _mm256_set1_ps(*cutoff);
+++ target_vec = _mm256_setzero_ps();
+++
+++ unsigned int i;
+++
+++ for (i = 0; i < eighth_points; ++i) {
+++ x_to_1 = _mm256_load_ps(src0);
+++ x_to_1 = _mm256_max_ps(x_to_1, cutoff_vec);
+++ x_to_2 = _mm256_mul_ps(x_to_1, x_to_1); // x^2
+++ x_to_3 = _mm256_mul_ps(x_to_1, x_to_2); // x^3
+++ // x^1 * x^3 is slightly faster than x^2 * x^2
+++ x_to_4 = _mm256_mul_ps(x_to_1, x_to_3); // x^4
+++
+++ x_to_2 = _mm256_mul_ps(x_to_2, cpa1); // cpa[1] * x^2
+++ x_to_4 = _mm256_mul_ps(x_to_4, cpa3); // cpa[3] * x^4
+++
+++ x_to_1 = _mm256_fmadd_ps(x_to_1, cpa0, x_to_2);
+++ x_to_3 = _mm256_fmadd_ps(x_to_3, cpa2, x_to_4);
+++ // this is slightly faster than result += (x_to_1 + x_to_3)
+++ target_vec = _mm256_add_ps(x_to_1, target_vec);
+++ target_vec = _mm256_add_ps(x_to_3, target_vec);
+++
+++ src0 += 8;
+++ }
+++
+++ // the hadd for vector reduction has very very slight impact @ 50k iters
+++ __VOLK_ATTR_ALIGNED(32) float temp_results[8];
+++ target_vec = _mm256_hadd_ps(
+++ target_vec,
+++ target_vec); // x0+x1 | x2+x3 | x0+x1 | x2+x3 || x4+x5 | x6+x7 | x4+x5 | x6+x7
+++ _mm256_store_ps(temp_results, target_vec);
+++ *target = temp_results[0] + temp_results[1] + temp_results[4] + temp_results[5];
+++
+++ for (i = eighth_points * 8; i < num_points; ++i) {
+++ fst = *src0++;
+++ fst = MAX(fst, *cutoff);
+++ sq = fst * fst;
+++ thrd = fst * sq;
+++ frth = sq * sq;
+++ *target += (center_point_array[0] * fst + center_point_array[1] * sq +
+++ center_point_array[2] * thrd + center_point_array[3] * frth);
+++ }
+++ *target += (float)(num_points)*center_point_array[4];
++ }
++ #endif // LV_HAVE_AVX && LV_HAVE_FMA
++
++ #ifdef LV_HAVE_AVX
++-#include<immintrin.h>
+++#include <immintrin.h>
++
++-static inline void
++-volk_32f_x3_sum_of_poly_32f_a_avx(float* target, float* src0, float* center_point_array,
++- float* cutoff, unsigned int num_points)
+++static inline void volk_32f_x3_sum_of_poly_32f_a_avx(float* target,
+++ float* src0,
+++ float* center_point_array,
+++ float* cutoff,
+++ unsigned int num_points)
++ {
++- const unsigned int eighth_points = num_points / 8;
++- float fst = 0.0;
++- float sq = 0.0;
++- float thrd = 0.0;
++- float frth = 0.0;
++-
++- __m256 cpa0, cpa1, cpa2, cpa3, cutoff_vec;
++- __m256 target_vec;
++- __m256 x_to_1, x_to_2, x_to_3, x_to_4;
++-
++- cpa0 = _mm256_set1_ps(center_point_array[0]);
++- cpa1 = _mm256_set1_ps(center_point_array[1]);
++- cpa2 = _mm256_set1_ps(center_point_array[2]);
++- cpa3 = _mm256_set1_ps(center_point_array[3]);
++- cutoff_vec = _mm256_set1_ps(*cutoff);
++- target_vec = _mm256_setzero_ps();
++-
++- unsigned int i;
++-
++- for(i = 0; i < eighth_points; ++i) {
++- x_to_1 = _mm256_load_ps(src0);
++- x_to_1 = _mm256_max_ps(x_to_1, cutoff_vec);
++- x_to_2 = _mm256_mul_ps(x_to_1, x_to_1); // x^2
++- x_to_3 = _mm256_mul_ps(x_to_1, x_to_2); // x^3
++- // x^1 * x^3 is slightly faster than x^2 * x^2
++- x_to_4 = _mm256_mul_ps(x_to_1, x_to_3); // x^4
++-
++- x_to_1 = _mm256_mul_ps(x_to_1, cpa0); // cpa[0] * x^1
++- x_to_2 = _mm256_mul_ps(x_to_2, cpa1); // cpa[1] * x^2
++- x_to_3 = _mm256_mul_ps(x_to_3, cpa2); // cpa[2] * x^3
++- x_to_4 = _mm256_mul_ps(x_to_4, cpa3); // cpa[3] * x^4
++-
++- x_to_1 = _mm256_add_ps(x_to_1, x_to_2);
++- x_to_3 = _mm256_add_ps(x_to_3, x_to_4);
++- // this is slightly faster than result += (x_to_1 + x_to_3)
++- target_vec = _mm256_add_ps(x_to_1, target_vec);
++- target_vec = _mm256_add_ps(x_to_3, target_vec);
++-
++- src0 += 8;
++- }
++-
++- // the hadd for vector reduction has very very slight impact @ 50k iters
++- __VOLK_ATTR_ALIGNED(32) float temp_results[8];
++- target_vec = _mm256_hadd_ps(target_vec, target_vec); // x0+x1 | x2+x3 | x0+x1 | x2+x3 || x4+x5 | x6+x7 | x4+x5 | x6+x7
++- _mm256_store_ps(temp_results, target_vec);
++- *target = temp_results[0] + temp_results[1] + temp_results[4] + temp_results[5];
++-
++- for(i = eighth_points*8; i < num_points; ++i) {
++- fst = *src0++;
++- fst = MAX(fst, *cutoff);
++- sq = fst * fst;
++- thrd = fst * sq;
++- frth = sq * sq;
++- *target += (center_point_array[0] * fst +
++- center_point_array[1] * sq +
++- center_point_array[2] * thrd +
++- center_point_array[3] * frth);
++- }
++- *target += (float)(num_points) * center_point_array[4];
+++ const unsigned int eighth_points = num_points / 8;
+++ float fst = 0.0;
+++ float sq = 0.0;
+++ float thrd = 0.0;
+++ float frth = 0.0;
+++
+++ __m256 cpa0, cpa1, cpa2, cpa3, cutoff_vec;
+++ __m256 target_vec;
+++ __m256 x_to_1, x_to_2, x_to_3, x_to_4;
+++
+++ cpa0 = _mm256_set1_ps(center_point_array[0]);
+++ cpa1 = _mm256_set1_ps(center_point_array[1]);
+++ cpa2 = _mm256_set1_ps(center_point_array[2]);
+++ cpa3 = _mm256_set1_ps(center_point_array[3]);
+++ cutoff_vec = _mm256_set1_ps(*cutoff);
+++ target_vec = _mm256_setzero_ps();
+++
+++ unsigned int i;
+++
+++ for (i = 0; i < eighth_points; ++i) {
+++ x_to_1 = _mm256_load_ps(src0);
+++ x_to_1 = _mm256_max_ps(x_to_1, cutoff_vec);
+++ x_to_2 = _mm256_mul_ps(x_to_1, x_to_1); // x^2
+++ x_to_3 = _mm256_mul_ps(x_to_1, x_to_2); // x^3
+++ // x^1 * x^3 is slightly faster than x^2 * x^2
+++ x_to_4 = _mm256_mul_ps(x_to_1, x_to_3); // x^4
+++
+++ x_to_1 = _mm256_mul_ps(x_to_1, cpa0); // cpa[0] * x^1
+++ x_to_2 = _mm256_mul_ps(x_to_2, cpa1); // cpa[1] * x^2
+++ x_to_3 = _mm256_mul_ps(x_to_3, cpa2); // cpa[2] * x^3
+++ x_to_4 = _mm256_mul_ps(x_to_4, cpa3); // cpa[3] * x^4
+++
+++ x_to_1 = _mm256_add_ps(x_to_1, x_to_2);
+++ x_to_3 = _mm256_add_ps(x_to_3, x_to_4);
+++ // this is slightly faster than result += (x_to_1 + x_to_3)
+++ target_vec = _mm256_add_ps(x_to_1, target_vec);
+++ target_vec = _mm256_add_ps(x_to_3, target_vec);
+++
+++ src0 += 8;
+++ }
+++
+++ // the hadd for vector reduction has very very slight impact @ 50k iters
+++ __VOLK_ATTR_ALIGNED(32) float temp_results[8];
+++ target_vec = _mm256_hadd_ps(
+++ target_vec,
+++ target_vec); // x0+x1 | x2+x3 | x0+x1 | x2+x3 || x4+x5 | x6+x7 | x4+x5 | x6+x7
+++ _mm256_store_ps(temp_results, target_vec);
+++ *target = temp_results[0] + temp_results[1] + temp_results[4] + temp_results[5];
+++
+++ for (i = eighth_points * 8; i < num_points; ++i) {
+++ fst = *src0++;
+++ fst = MAX(fst, *cutoff);
+++ sq = fst * fst;
+++ thrd = fst * sq;
+++ frth = sq * sq;
+++ *target += (center_point_array[0] * fst + center_point_array[1] * sq +
+++ center_point_array[2] * thrd + center_point_array[3] * frth);
+++ }
+++ *target += (float)(num_points)*center_point_array[4];
++ }
++ #endif // LV_HAVE_AVX
++
++
++-
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32f_x3_sum_of_poly_32f_generic(float* target, float* src0, float* center_point_array,
++- float* cutoff, unsigned int num_points)
+++static inline void volk_32f_x3_sum_of_poly_32f_generic(float* target,
+++ float* src0,
+++ float* center_point_array,
+++ float* cutoff,
+++ unsigned int num_points)
++ {
++- const unsigned int eighth_points = num_points / 8;
++-
++- float result[8] = {0.0f,0.0f,0.0f,0.0f, 0.0f,0.0f,0.0f,0.0f};
++- float fst = 0.0f;
++- float sq = 0.0f;
++- float thrd = 0.0f;
++- float frth = 0.0f;
++-
++- unsigned int i = 0;
++- unsigned int k = 0;
++- for(i = 0; i < eighth_points; ++i) {
++- for(k = 0; k < 8; ++k) {
++- fst = *src0++;
++- fst = MAX(fst, *cutoff);
++- sq = fst * fst;
++- thrd = fst * sq;
++- frth = fst * thrd;
++- result[k] += center_point_array[0] * fst + center_point_array[1] * sq;
++- result[k] += center_point_array[2] * thrd + center_point_array[3] * frth;
+++ const unsigned int eighth_points = num_points / 8;
+++
+++ float result[8] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+++ float fst = 0.0f;
+++ float sq = 0.0f;
+++ float thrd = 0.0f;
+++ float frth = 0.0f;
+++
+++ unsigned int i = 0;
+++ unsigned int k = 0;
+++ for (i = 0; i < eighth_points; ++i) {
+++ for (k = 0; k < 8; ++k) {
+++ fst = *src0++;
+++ fst = MAX(fst, *cutoff);
+++ sq = fst * fst;
+++ thrd = fst * sq;
+++ frth = fst * thrd;
+++ result[k] += center_point_array[0] * fst + center_point_array[1] * sq;
+++ result[k] += center_point_array[2] * thrd + center_point_array[3] * frth;
+++ }
++ }
++- }
++- for(k = 0; k < 8; k+=2)
++- result[k] = result[k]+result[k+1];
++-
++- *target = result[0] + result[2] + result[4] + result[6];
++-
++- for(i = eighth_points*8; i < num_points; ++i) {
++- fst = *src0++;
++- fst = MAX(fst, *cutoff);
++- sq = fst * fst;
++- thrd = fst * sq;
++- frth = fst * thrd;
++- *target += (center_point_array[0] * fst +
++- center_point_array[1] * sq +
++- center_point_array[2] * thrd +
++- center_point_array[3] * frth);
++- }
++- *target += (float)(num_points) * center_point_array[4];
+++ for (k = 0; k < 8; k += 2)
+++ result[k] = result[k] + result[k + 1];
+++
+++ *target = result[0] + result[2] + result[4] + result[6];
+++
+++ for (i = eighth_points * 8; i < num_points; ++i) {
+++ fst = *src0++;
+++ fst = MAX(fst, *cutoff);
+++ sq = fst * fst;
+++ thrd = fst * sq;
+++ frth = fst * thrd;
+++ *target += (center_point_array[0] * fst + center_point_array[1] * sq +
+++ center_point_array[2] * thrd + center_point_array[3] * frth);
+++ }
+++ *target += (float)(num_points)*center_point_array[4];
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -372,51 +377,52 @@ volk_32f_x3_sum_of_poly_32f_generic(float* target, float* src0, float* center_po
++ #include <arm_neon.h>
++
++ static inline void
++-volk_32f_x3_sum_of_poly_32f_a_neon(float* __restrict target, float* __restrict src0,
+++volk_32f_x3_sum_of_poly_32f_a_neon(float* __restrict target,
+++ float* __restrict src0,
++ float* __restrict center_point_array,
++- float* __restrict cutoff, unsigned int num_points)
+++ float* __restrict cutoff,
+++ unsigned int num_points)
++ {
++- unsigned int i;
++- float zero[4] = {0.0f, 0.0f, 0.0f, 0.0f };
++-
++- float32x2_t x_to_1, x_to_2, x_to_3, x_to_4;
++- float32x2_t cutoff_vector;
++- float32x2x2_t x_low, x_high;
++- float32x4_t x_qvector, c_qvector, cpa_qvector;
++- float accumulator;
++- float res_accumulators[4];
++-
++- c_qvector = vld1q_f32( zero );
++- // load the cutoff in to a vector
++- cutoff_vector = vdup_n_f32( *cutoff );
++- // ... center point array
++- cpa_qvector = vld1q_f32( center_point_array );
++-
++- for(i=0; i < num_points; ++i) {
++- // load x (src0)
++- x_to_1 = vdup_n_f32( *src0++ );
++-
++- // Get a vector of max(src0, cutoff)
++- x_to_1 = vmax_f32(x_to_1, cutoff_vector ); // x^1
++- x_to_2 = vmul_f32(x_to_1, x_to_1); // x^2
++- x_to_3 = vmul_f32(x_to_2, x_to_1); // x^3
++- x_to_4 = vmul_f32(x_to_3, x_to_1); // x^4
++- // zip up doubles to interleave
++- x_low = vzip_f32(x_to_1, x_to_2); // [x^2 | x^1 || x^2 | x^1]
++- x_high = vzip_f32(x_to_3, x_to_4); // [x^4 | x^3 || x^4 | x^3]
++- // float32x4_t vcombine_f32(float32x2_t low, float32x2_t high); // VMOV d0,d0
++- x_qvector = vcombine_f32(x_low.val[0], x_high.val[0]);
++- // now we finally have [x^4 | x^3 | x^2 | x] !
++-
++- c_qvector = vmlaq_f32(c_qvector, x_qvector, cpa_qvector);
++-
++- }
++- // there should be better vector reduction techniques
++- vst1q_f32(res_accumulators, c_qvector );
++- accumulator = res_accumulators[0] + res_accumulators[1] +
++- res_accumulators[2] + res_accumulators[3];
++-
++- *target = accumulator + (float)num_points * center_point_array[4];
+++ unsigned int i;
+++ float zero[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+++
+++ float32x2_t x_to_1, x_to_2, x_to_3, x_to_4;
+++ float32x2_t cutoff_vector;
+++ float32x2x2_t x_low, x_high;
+++ float32x4_t x_qvector, c_qvector, cpa_qvector;
+++ float accumulator;
+++ float res_accumulators[4];
+++
+++ c_qvector = vld1q_f32(zero);
+++ // load the cutoff in to a vector
+++ cutoff_vector = vdup_n_f32(*cutoff);
+++ // ... center point array
+++ cpa_qvector = vld1q_f32(center_point_array);
+++
+++ for (i = 0; i < num_points; ++i) {
+++ // load x (src0)
+++ x_to_1 = vdup_n_f32(*src0++);
+++
+++ // Get a vector of max(src0, cutoff)
+++ x_to_1 = vmax_f32(x_to_1, cutoff_vector); // x^1
+++ x_to_2 = vmul_f32(x_to_1, x_to_1); // x^2
+++ x_to_3 = vmul_f32(x_to_2, x_to_1); // x^3
+++ x_to_4 = vmul_f32(x_to_3, x_to_1); // x^4
+++ // zip up doubles to interleave
+++ x_low = vzip_f32(x_to_1, x_to_2); // [x^2 | x^1 || x^2 | x^1]
+++ x_high = vzip_f32(x_to_3, x_to_4); // [x^4 | x^3 || x^4 | x^3]
+++ // float32x4_t vcombine_f32(float32x2_t low, float32x2_t high); // VMOV d0,d0
+++ x_qvector = vcombine_f32(x_low.val[0], x_high.val[0]);
+++ // now we finally have [x^4 | x^3 | x^2 | x] !
+++
+++ c_qvector = vmlaq_f32(c_qvector, x_qvector, cpa_qvector);
+++ }
+++ // there should be better vector reduction techniques
+++ vst1q_f32(res_accumulators, c_qvector);
+++ accumulator = res_accumulators[0] + res_accumulators[1] + res_accumulators[2] +
+++ res_accumulators[3];
+++
+++ *target = accumulator + (float)num_points * center_point_array[4];
++ }
++
++ #endif /* LV_HAVE_NEON */
++@@ -425,82 +431,82 @@ volk_32f_x3_sum_of_poly_32f_a_neon(float* __restrict target, float* __restrict s
++ #ifdef LV_HAVE_NEON
++
++ static inline void
++-volk_32f_x3_sum_of_poly_32f_neonvert(float* __restrict target, float* __restrict src0,
+++volk_32f_x3_sum_of_poly_32f_neonvert(float* __restrict target,
+++ float* __restrict src0,
++ float* __restrict center_point_array,
++- float* __restrict cutoff, unsigned int num_points)
+++ float* __restrict cutoff,
+++ unsigned int num_points)
++ {
++- unsigned int i;
++- float zero[4] = {0.0f, 0.0f, 0.0f, 0.0f };
++-
++- float accumulator;
++-
++- float32x4_t accumulator1_vec, accumulator2_vec, accumulator3_vec, accumulator4_vec;
++- accumulator1_vec = vld1q_f32(zero);
++- accumulator2_vec = vld1q_f32(zero);
++- accumulator3_vec = vld1q_f32(zero);
++- accumulator4_vec = vld1q_f32(zero);
++- float32x4_t x_to_1, x_to_2, x_to_3, x_to_4;
++- float32x4_t cutoff_vector, cpa_0, cpa_1, cpa_2, cpa_3;
++-
++- // load the cutoff in to a vector
++- cutoff_vector = vdupq_n_f32( *cutoff );
++- // ... center point array
++- cpa_0 = vdupq_n_f32(center_point_array[0]);
++- cpa_1 = vdupq_n_f32(center_point_array[1]);
++- cpa_2 = vdupq_n_f32(center_point_array[2]);
++- cpa_3 = vdupq_n_f32(center_point_array[3]);
++-
++- // nathan is not sure why this is slower *and* wrong compared to neonvertfma
++- for(i=0; i < num_points/4; ++i) {
++- // load x
++- x_to_1 = vld1q_f32( src0 );
++-
++- // Get a vector of max(src0, cutoff)
++- x_to_1 = vmaxq_f32(x_to_1, cutoff_vector ); // x^1
++- x_to_2 = vmulq_f32(x_to_1, x_to_1); // x^2
++- x_to_3 = vmulq_f32(x_to_2, x_to_1); // x^3
++- x_to_4 = vmulq_f32(x_to_3, x_to_1); // x^4
++- x_to_1 = vmulq_f32(x_to_1, cpa_0);
++- x_to_2 = vmulq_f32(x_to_2, cpa_1);
++- x_to_3 = vmulq_f32(x_to_3, cpa_2);
++- x_to_4 = vmulq_f32(x_to_4, cpa_3);
++- accumulator1_vec = vaddq_f32(accumulator1_vec, x_to_1);
++- accumulator2_vec = vaddq_f32(accumulator2_vec, x_to_2);
++- accumulator3_vec = vaddq_f32(accumulator3_vec, x_to_3);
++- accumulator4_vec = vaddq_f32(accumulator4_vec, x_to_4);
++-
++- src0 += 4;
++- }
++- accumulator1_vec = vaddq_f32(accumulator1_vec, accumulator2_vec);
++- accumulator3_vec = vaddq_f32(accumulator3_vec, accumulator4_vec);
++- accumulator1_vec = vaddq_f32(accumulator1_vec, accumulator3_vec);
++-
++- __VOLK_ATTR_ALIGNED(32) float res_accumulators[4];
++- vst1q_f32(res_accumulators, accumulator1_vec );
++- accumulator = res_accumulators[0] + res_accumulators[1] +
++- res_accumulators[2] + res_accumulators[3];
++-
++- float fst = 0.0;
++- float sq = 0.0;
++- float thrd = 0.0;
++- float frth = 0.0;
++-
++- for(i = 4*num_points/4; i < num_points; ++i) {
++- fst = src0[i];
++- fst = MAX(fst, *cutoff);
++-
++- sq = fst * fst;
++- thrd = fst * sq;
++- frth = sq * sq;
++- //fith = sq * thrd;
++-
++- accumulator += (center_point_array[0] * fst +
++- center_point_array[1] * sq +
++- center_point_array[2] * thrd +
++- center_point_array[3] * frth); //+
++- }
++-
++- *target = accumulator + (float)num_points * center_point_array[4];
+++ unsigned int i;
+++ float zero[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+++
+++ float accumulator;
+++
+++ float32x4_t accumulator1_vec, accumulator2_vec, accumulator3_vec, accumulator4_vec;
+++ accumulator1_vec = vld1q_f32(zero);
+++ accumulator2_vec = vld1q_f32(zero);
+++ accumulator3_vec = vld1q_f32(zero);
+++ accumulator4_vec = vld1q_f32(zero);
+++ float32x4_t x_to_1, x_to_2, x_to_3, x_to_4;
+++ float32x4_t cutoff_vector, cpa_0, cpa_1, cpa_2, cpa_3;
+++
+++ // load the cutoff in to a vector
+++ cutoff_vector = vdupq_n_f32(*cutoff);
+++ // ... center point array
+++ cpa_0 = vdupq_n_f32(center_point_array[0]);
+++ cpa_1 = vdupq_n_f32(center_point_array[1]);
+++ cpa_2 = vdupq_n_f32(center_point_array[2]);
+++ cpa_3 = vdupq_n_f32(center_point_array[3]);
+++
+++ // nathan is not sure why this is slower *and* wrong compared to neonvertfma
+++ for (i = 0; i < num_points / 4; ++i) {
+++ // load x
+++ x_to_1 = vld1q_f32(src0);
+++
+++ // Get a vector of max(src0, cutoff)
+++ x_to_1 = vmaxq_f32(x_to_1, cutoff_vector); // x^1
+++ x_to_2 = vmulq_f32(x_to_1, x_to_1); // x^2
+++ x_to_3 = vmulq_f32(x_to_2, x_to_1); // x^3
+++ x_to_4 = vmulq_f32(x_to_3, x_to_1); // x^4
+++ x_to_1 = vmulq_f32(x_to_1, cpa_0);
+++ x_to_2 = vmulq_f32(x_to_2, cpa_1);
+++ x_to_3 = vmulq_f32(x_to_3, cpa_2);
+++ x_to_4 = vmulq_f32(x_to_4, cpa_3);
+++ accumulator1_vec = vaddq_f32(accumulator1_vec, x_to_1);
+++ accumulator2_vec = vaddq_f32(accumulator2_vec, x_to_2);
+++ accumulator3_vec = vaddq_f32(accumulator3_vec, x_to_3);
+++ accumulator4_vec = vaddq_f32(accumulator4_vec, x_to_4);
+++
+++ src0 += 4;
+++ }
+++ accumulator1_vec = vaddq_f32(accumulator1_vec, accumulator2_vec);
+++ accumulator3_vec = vaddq_f32(accumulator3_vec, accumulator4_vec);
+++ accumulator1_vec = vaddq_f32(accumulator1_vec, accumulator3_vec);
+++
+++ __VOLK_ATTR_ALIGNED(32) float res_accumulators[4];
+++ vst1q_f32(res_accumulators, accumulator1_vec);
+++ accumulator = res_accumulators[0] + res_accumulators[1] + res_accumulators[2] +
+++ res_accumulators[3];
+++
+++ float fst = 0.0;
+++ float sq = 0.0;
+++ float thrd = 0.0;
+++ float frth = 0.0;
+++
+++ for (i = 4 * num_points / 4; i < num_points; ++i) {
+++ fst = src0[i];
+++ fst = MAX(fst, *cutoff);
+++
+++ sq = fst * fst;
+++ thrd = fst * sq;
+++ frth = sq * sq;
+++ // fith = sq * thrd;
+++
+++ accumulator += (center_point_array[0] * fst + center_point_array[1] * sq +
+++ center_point_array[2] * thrd + center_point_array[3] * frth); //+
+++ }
+++
+++ *target = accumulator + (float)num_points * center_point_array[4];
++ }
++
++ #endif /* LV_HAVE_NEON */
++@@ -510,150 +516,154 @@ volk_32f_x3_sum_of_poly_32f_neonvert(float* __restrict target, float* __restrict
++ #ifndef INCLUDED_volk_32f_x3_sum_of_poly_32f_u_H
++ #define INCLUDED_volk_32f_x3_sum_of_poly_32f_u_H
++
++-#include<inttypes.h>
++-#include<stdio.h>
++-#include<volk/volk_complex.h>
+++#include <inttypes.h>
+++#include <stdio.h>
+++#include <volk/volk_complex.h>
++
++ #ifndef MAX
++-#define MAX(X,Y) ((X) > (Y)?(X):(Y))
+++#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
++ #endif
++
++ #if LV_HAVE_AVX && LV_HAVE_FMA
++-#include<immintrin.h>
+++#include <immintrin.h>
++
++-static inline void
++-volk_32f_x3_sum_of_poly_32f_u_avx_fma(float* target, float* src0, float* center_point_array,
++- float* cutoff, unsigned int num_points)
+++static inline void volk_32f_x3_sum_of_poly_32f_u_avx_fma(float* target,
+++ float* src0,
+++ float* center_point_array,
+++ float* cutoff,
+++ unsigned int num_points)
++ {
++- const unsigned int eighth_points = num_points / 8;
++- float fst = 0.0;
++- float sq = 0.0;
++- float thrd = 0.0;
++- float frth = 0.0;
++-
++- __m256 cpa0, cpa1, cpa2, cpa3, cutoff_vec;
++- __m256 target_vec;
++- __m256 x_to_1, x_to_2, x_to_3, x_to_4;
++-
++- cpa0 = _mm256_set1_ps(center_point_array[0]);
++- cpa1 = _mm256_set1_ps(center_point_array[1]);
++- cpa2 = _mm256_set1_ps(center_point_array[2]);
++- cpa3 = _mm256_set1_ps(center_point_array[3]);
++- cutoff_vec = _mm256_set1_ps(*cutoff);
++- target_vec = _mm256_setzero_ps();
++-
++- unsigned int i;
++-
++- for(i = 0; i < eighth_points; ++i) {
++- x_to_1 = _mm256_loadu_ps(src0);
++- x_to_1 = _mm256_max_ps(x_to_1, cutoff_vec);
++- x_to_2 = _mm256_mul_ps(x_to_1, x_to_1); // x^2
++- x_to_3 = _mm256_mul_ps(x_to_1, x_to_2); // x^3
++- // x^1 * x^3 is slightly faster than x^2 * x^2
++- x_to_4 = _mm256_mul_ps(x_to_1, x_to_3); // x^4
++-
++- x_to_2 = _mm256_mul_ps(x_to_2, cpa1); // cpa[1] * x^2
++- x_to_4 = _mm256_mul_ps(x_to_4, cpa3); // cpa[3] * x^4
++-
++- x_to_1 = _mm256_fmadd_ps(x_to_1, cpa0, x_to_2);
++- x_to_3 = _mm256_fmadd_ps(x_to_3, cpa2, x_to_4);
++- // this is slightly faster than result += (x_to_1 + x_to_3)
++- target_vec = _mm256_add_ps(x_to_1, target_vec);
++- target_vec = _mm256_add_ps(x_to_3, target_vec);
++-
++- src0 += 8;
++- }
++-
++- // the hadd for vector reduction has very very slight impact @ 50k iters
++- __VOLK_ATTR_ALIGNED(32) float temp_results[8];
++- target_vec = _mm256_hadd_ps(target_vec, target_vec); // x0+x1 | x2+x3 | x0+x1 | x2+x3 || x4+x5 | x6+x7 | x4+x5 | x6+x7
++- _mm256_storeu_ps(temp_results, target_vec);
++- *target = temp_results[0] + temp_results[1] + temp_results[4] + temp_results[5];
++-
++- for(i = eighth_points*8; i < num_points; ++i) {
++- fst = *src0++;
++- fst = MAX(fst, *cutoff);
++- sq = fst * fst;
++- thrd = fst * sq;
++- frth = sq * sq;
++- *target += (center_point_array[0] * fst +
++- center_point_array[1] * sq +
++- center_point_array[2] * thrd +
++- center_point_array[3] * frth);
++- }
++-
++- *target += (float)(num_points) * center_point_array[4];
+++ const unsigned int eighth_points = num_points / 8;
+++ float fst = 0.0;
+++ float sq = 0.0;
+++ float thrd = 0.0;
+++ float frth = 0.0;
+++
+++ __m256 cpa0, cpa1, cpa2, cpa3, cutoff_vec;
+++ __m256 target_vec;
+++ __m256 x_to_1, x_to_2, x_to_3, x_to_4;
+++
+++ cpa0 = _mm256_set1_ps(center_point_array[0]);
+++ cpa1 = _mm256_set1_ps(center_point_array[1]);
+++ cpa2 = _mm256_set1_ps(center_point_array[2]);
+++ cpa3 = _mm256_set1_ps(center_point_array[3]);
+++ cutoff_vec = _mm256_set1_ps(*cutoff);
+++ target_vec = _mm256_setzero_ps();
+++
+++ unsigned int i;
+++
+++ for (i = 0; i < eighth_points; ++i) {
+++ x_to_1 = _mm256_loadu_ps(src0);
+++ x_to_1 = _mm256_max_ps(x_to_1, cutoff_vec);
+++ x_to_2 = _mm256_mul_ps(x_to_1, x_to_1); // x^2
+++ x_to_3 = _mm256_mul_ps(x_to_1, x_to_2); // x^3
+++ // x^1 * x^3 is slightly faster than x^2 * x^2
+++ x_to_4 = _mm256_mul_ps(x_to_1, x_to_3); // x^4
+++
+++ x_to_2 = _mm256_mul_ps(x_to_2, cpa1); // cpa[1] * x^2
+++ x_to_4 = _mm256_mul_ps(x_to_4, cpa3); // cpa[3] * x^4
+++
+++ x_to_1 = _mm256_fmadd_ps(x_to_1, cpa0, x_to_2);
+++ x_to_3 = _mm256_fmadd_ps(x_to_3, cpa2, x_to_4);
+++ // this is slightly faster than result += (x_to_1 + x_to_3)
+++ target_vec = _mm256_add_ps(x_to_1, target_vec);
+++ target_vec = _mm256_add_ps(x_to_3, target_vec);
+++
+++ src0 += 8;
+++ }
+++
+++ // the hadd for vector reduction has very very slight impact @ 50k iters
+++ __VOLK_ATTR_ALIGNED(32) float temp_results[8];
+++ target_vec = _mm256_hadd_ps(
+++ target_vec,
+++ target_vec); // x0+x1 | x2+x3 | x0+x1 | x2+x3 || x4+x5 | x6+x7 | x4+x5 | x6+x7
+++ _mm256_storeu_ps(temp_results, target_vec);
+++ *target = temp_results[0] + temp_results[1] + temp_results[4] + temp_results[5];
+++
+++ for (i = eighth_points * 8; i < num_points; ++i) {
+++ fst = *src0++;
+++ fst = MAX(fst, *cutoff);
+++ sq = fst * fst;
+++ thrd = fst * sq;
+++ frth = sq * sq;
+++ *target += (center_point_array[0] * fst + center_point_array[1] * sq +
+++ center_point_array[2] * thrd + center_point_array[3] * frth);
+++ }
+++
+++ *target += (float)(num_points)*center_point_array[4];
++ }
++ #endif // LV_HAVE_AVX && LV_HAVE_FMA
++
++ #ifdef LV_HAVE_AVX
++-#include<immintrin.h>
+++#include <immintrin.h>
++
++-static inline void
++-volk_32f_x3_sum_of_poly_32f_u_avx(float* target, float* src0, float* center_point_array,
++- float* cutoff, unsigned int num_points)
+++static inline void volk_32f_x3_sum_of_poly_32f_u_avx(float* target,
+++ float* src0,
+++ float* center_point_array,
+++ float* cutoff,
+++ unsigned int num_points)
++ {
++- const unsigned int eighth_points = num_points / 8;
++- float fst = 0.0;
++- float sq = 0.0;
++- float thrd = 0.0;
++- float frth = 0.0;
++-
++- __m256 cpa0, cpa1, cpa2, cpa3, cutoff_vec;
++- __m256 target_vec;
++- __m256 x_to_1, x_to_2, x_to_3, x_to_4;
++-
++- cpa0 = _mm256_set1_ps(center_point_array[0]);
++- cpa1 = _mm256_set1_ps(center_point_array[1]);
++- cpa2 = _mm256_set1_ps(center_point_array[2]);
++- cpa3 = _mm256_set1_ps(center_point_array[3]);
++- cutoff_vec = _mm256_set1_ps(*cutoff);
++- target_vec = _mm256_setzero_ps();
++-
++- unsigned int i;
++-
++- for(i = 0; i < eighth_points; ++i) {
++- x_to_1 = _mm256_loadu_ps(src0);
++- x_to_1 = _mm256_max_ps(x_to_1, cutoff_vec);
++- x_to_2 = _mm256_mul_ps(x_to_1, x_to_1); // x^2
++- x_to_3 = _mm256_mul_ps(x_to_1, x_to_2); // x^3
++- // x^1 * x^3 is slightly faster than x^2 * x^2
++- x_to_4 = _mm256_mul_ps(x_to_1, x_to_3); // x^4
++-
++- x_to_1 = _mm256_mul_ps(x_to_1, cpa0); // cpa[0] * x^1
++- x_to_2 = _mm256_mul_ps(x_to_2, cpa1); // cpa[1] * x^2
++- x_to_3 = _mm256_mul_ps(x_to_3, cpa2); // cpa[2] * x^3
++- x_to_4 = _mm256_mul_ps(x_to_4, cpa3); // cpa[3] * x^4
++-
++- x_to_1 = _mm256_add_ps(x_to_1, x_to_2);
++- x_to_3 = _mm256_add_ps(x_to_3, x_to_4);
++- // this is slightly faster than result += (x_to_1 + x_to_3)
++- target_vec = _mm256_add_ps(x_to_1, target_vec);
++- target_vec = _mm256_add_ps(x_to_3, target_vec);
++-
++- src0 += 8;
++- }
++-
++- // the hadd for vector reduction has very very slight impact @ 50k iters
++- __VOLK_ATTR_ALIGNED(32) float temp_results[8];
++- target_vec = _mm256_hadd_ps(target_vec, target_vec); // x0+x1 | x2+x3 | x0+x1 | x2+x3 || x4+x5 | x6+x7 | x4+x5 | x6+x7
++- _mm256_storeu_ps(temp_results, target_vec);
++- *target = temp_results[0] + temp_results[1] + temp_results[4] + temp_results[5];
++-
++- for(i = eighth_points*8; i < num_points; ++i) {
++- fst = *src0++;
++- fst = MAX(fst, *cutoff);
++- sq = fst * fst;
++- thrd = fst * sq;
++- frth = sq * sq;
++-
++- *target += (center_point_array[0] * fst +
++- center_point_array[1] * sq +
++- center_point_array[2] * thrd +
++- center_point_array[3] * frth);
++- }
++-
++- *target += (float)(num_points) * center_point_array[4];
+++ const unsigned int eighth_points = num_points / 8;
+++ float fst = 0.0;
+++ float sq = 0.0;
+++ float thrd = 0.0;
+++ float frth = 0.0;
+++
+++ __m256 cpa0, cpa1, cpa2, cpa3, cutoff_vec;
+++ __m256 target_vec;
+++ __m256 x_to_1, x_to_2, x_to_3, x_to_4;
+++
+++ cpa0 = _mm256_set1_ps(center_point_array[0]);
+++ cpa1 = _mm256_set1_ps(center_point_array[1]);
+++ cpa2 = _mm256_set1_ps(center_point_array[2]);
+++ cpa3 = _mm256_set1_ps(center_point_array[3]);
+++ cutoff_vec = _mm256_set1_ps(*cutoff);
+++ target_vec = _mm256_setzero_ps();
+++
+++ unsigned int i;
+++
+++ for (i = 0; i < eighth_points; ++i) {
+++ x_to_1 = _mm256_loadu_ps(src0);
+++ x_to_1 = _mm256_max_ps(x_to_1, cutoff_vec);
+++ x_to_2 = _mm256_mul_ps(x_to_1, x_to_1); // x^2
+++ x_to_3 = _mm256_mul_ps(x_to_1, x_to_2); // x^3
+++ // x^1 * x^3 is slightly faster than x^2 * x^2
+++ x_to_4 = _mm256_mul_ps(x_to_1, x_to_3); // x^4
+++
+++ x_to_1 = _mm256_mul_ps(x_to_1, cpa0); // cpa[0] * x^1
+++ x_to_2 = _mm256_mul_ps(x_to_2, cpa1); // cpa[1] * x^2
+++ x_to_3 = _mm256_mul_ps(x_to_3, cpa2); // cpa[2] * x^3
+++ x_to_4 = _mm256_mul_ps(x_to_4, cpa3); // cpa[3] * x^4
+++
+++ x_to_1 = _mm256_add_ps(x_to_1, x_to_2);
+++ x_to_3 = _mm256_add_ps(x_to_3, x_to_4);
+++ // this is slightly faster than result += (x_to_1 + x_to_3)
+++ target_vec = _mm256_add_ps(x_to_1, target_vec);
+++ target_vec = _mm256_add_ps(x_to_3, target_vec);
+++
+++ src0 += 8;
+++ }
+++
+++ // the hadd for vector reduction has very very slight impact @ 50k iters
+++ __VOLK_ATTR_ALIGNED(32) float temp_results[8];
+++ target_vec = _mm256_hadd_ps(
+++ target_vec,
+++ target_vec); // x0+x1 | x2+x3 | x0+x1 | x2+x3 || x4+x5 | x6+x7 | x4+x5 | x6+x7
+++ _mm256_storeu_ps(temp_results, target_vec);
+++ *target = temp_results[0] + temp_results[1] + temp_results[4] + temp_results[5];
+++
+++ for (i = eighth_points * 8; i < num_points; ++i) {
+++ fst = *src0++;
+++ fst = MAX(fst, *cutoff);
+++ sq = fst * fst;
+++ thrd = fst * sq;
+++ frth = sq * sq;
+++
+++ *target += (center_point_array[0] * fst + center_point_array[1] * sq +
+++ center_point_array[2] * thrd + center_point_array[3] * frth);
+++ }
+++
+++ *target += (float)(num_points)*center_point_array[4];
++ }
++ #endif // LV_HAVE_AVX
++
++diff --git a/kernels/volk/volk_32fc_32f_add_32fc.h b/kernels/volk/volk_32fc_32f_add_32fc.h
++index 86a3818..b25ca6a 100644
++--- a/kernels/volk/volk_32fc_32f_add_32fc.h
+++++ b/kernels/volk/volk_32fc_32f_add_32fc.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_32f_add_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_32f_add_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float*
+++ * bVector, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: First vector of input points.
++@@ -44,7 +44,8 @@
++ *
++ * \b Example
++ *
++- * The follow example adds the increasing and decreasing vectors such that the result of every summation pair is 10
+++ * The follow example adds the increasing and decreasing vectors such that the result of
+++ * every summation pair is 10
++ *
++ * \code
++ * int N = 10;
++@@ -75,18 +76,19 @@
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_32f_add_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32fc_32f_add_32fc_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const float* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -94,143 +96,150 @@ volk_32fc_32f_add_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_32f_add_32fc_u_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32fc_32f_add_32fc_u_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const float* bPtr= bVector;
++-
++- __m256 aVal1, aVal2, bVal, cVal1, cVal2;
++- __m256 cpx_b1, cpx_b2;
++- __m256 zero;
++- zero = _mm256_setzero_ps();
++- __m256 tmp1, tmp2;
++- for(;number < eighthPoints; number++){
++-
++- aVal1 = _mm256_loadu_ps((float *) aPtr);
++- aVal2 = _mm256_loadu_ps((float *) (aPtr+4));
++- bVal = _mm256_loadu_ps(bPtr);
++- cpx_b1 = _mm256_unpacklo_ps(bVal, zero); // b0, 0, b1, 0, b4, 0, b5, 0
++- cpx_b2 = _mm256_unpackhi_ps(bVal, zero); // b2, 0, b3, 0, b6, 0, b7, 0
++-
++- tmp1 = _mm256_permute2f128_ps(cpx_b1, cpx_b2, 0x0+(0x2<<4));
++- tmp2 = _mm256_permute2f128_ps(cpx_b1, cpx_b2, 0x1+(0x3<<4));
++-
++- cVal1 = _mm256_add_ps(aVal1, tmp1);
++- cVal2 = _mm256_add_ps(aVal2, tmp2);
++-
++- _mm256_storeu_ps((float *) cPtr, cVal1); // Store the results back into the C container
++- _mm256_storeu_ps((float *) (cPtr+4), cVal2); // Store the results back into the C container
++-
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const float* bPtr = bVector;
+++
+++ __m256 aVal1, aVal2, bVal, cVal1, cVal2;
+++ __m256 cpx_b1, cpx_b2;
+++ __m256 zero;
+++ zero = _mm256_setzero_ps();
+++ __m256 tmp1, tmp2;
+++ for (; number < eighthPoints; number++) {
+++
+++ aVal1 = _mm256_loadu_ps((float*)aPtr);
+++ aVal2 = _mm256_loadu_ps((float*)(aPtr + 4));
+++ bVal = _mm256_loadu_ps(bPtr);
+++ cpx_b1 = _mm256_unpacklo_ps(bVal, zero); // b0, 0, b1, 0, b4, 0, b5, 0
+++ cpx_b2 = _mm256_unpackhi_ps(bVal, zero); // b2, 0, b3, 0, b6, 0, b7, 0
+++
+++ tmp1 = _mm256_permute2f128_ps(cpx_b1, cpx_b2, 0x0 + (0x2 << 4));
+++ tmp2 = _mm256_permute2f128_ps(cpx_b1, cpx_b2, 0x1 + (0x3 << 4));
+++
+++ cVal1 = _mm256_add_ps(aVal1, tmp1);
+++ cVal2 = _mm256_add_ps(aVal2, tmp2);
+++
+++ _mm256_storeu_ps((float*)cPtr,
+++ cVal1); // Store the results back into the C container
+++ _mm256_storeu_ps((float*)(cPtr + 4),
+++ cVal2); // Store the results back into the C container
+++
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_32f_add_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32fc_32f_add_32fc_a_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const float* bPtr= bVector;
++-
++- __m256 aVal1, aVal2, bVal, cVal1, cVal2;
++- __m256 cpx_b1, cpx_b2;
++- __m256 zero;
++- zero = _mm256_setzero_ps();
++- __m256 tmp1, tmp2;
++- for(;number < eighthPoints; number++){
++-
++- aVal1 = _mm256_load_ps((float *) aPtr);
++- aVal2 = _mm256_load_ps((float *) (aPtr+4));
++- bVal = _mm256_load_ps(bPtr);
++- cpx_b1 = _mm256_unpacklo_ps(bVal, zero); // b0, 0, b1, 0, b4, 0, b5, 0
++- cpx_b2 = _mm256_unpackhi_ps(bVal, zero); // b2, 0, b3, 0, b6, 0, b7, 0
++-
++- tmp1 = _mm256_permute2f128_ps(cpx_b1, cpx_b2, 0x0+(0x2<<4));
++- tmp2 = _mm256_permute2f128_ps(cpx_b1, cpx_b2, 0x1+(0x3<<4));
++-
++- cVal1 = _mm256_add_ps(aVal1, tmp1);
++- cVal2 = _mm256_add_ps(aVal2, tmp2);
++-
++- _mm256_store_ps((float *) cPtr, cVal1); // Store the results back into the C container
++- _mm256_store_ps((float *) (cPtr+4), cVal2); // Store the results back into the C container
++-
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const float* bPtr = bVector;
+++
+++ __m256 aVal1, aVal2, bVal, cVal1, cVal2;
+++ __m256 cpx_b1, cpx_b2;
+++ __m256 zero;
+++ zero = _mm256_setzero_ps();
+++ __m256 tmp1, tmp2;
+++ for (; number < eighthPoints; number++) {
+++
+++ aVal1 = _mm256_load_ps((float*)aPtr);
+++ aVal2 = _mm256_load_ps((float*)(aPtr + 4));
+++ bVal = _mm256_load_ps(bPtr);
+++ cpx_b1 = _mm256_unpacklo_ps(bVal, zero); // b0, 0, b1, 0, b4, 0, b5, 0
+++ cpx_b2 = _mm256_unpackhi_ps(bVal, zero); // b2, 0, b3, 0, b6, 0, b7, 0
+++
+++ tmp1 = _mm256_permute2f128_ps(cpx_b1, cpx_b2, 0x0 + (0x2 << 4));
+++ tmp2 = _mm256_permute2f128_ps(cpx_b1, cpx_b2, 0x1 + (0x3 << 4));
+++
+++ cVal1 = _mm256_add_ps(aVal1, tmp1);
+++ cVal2 = _mm256_add_ps(aVal2, tmp2);
+++
+++ _mm256_store_ps((float*)cPtr,
+++ cVal1); // Store the results back into the C container
+++ _mm256_store_ps((float*)(cPtr + 4),
+++ cVal2); // Store the results back into the C container
+++
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32fc_32f_add_32fc_neon(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32fc_32f_add_32fc_neon(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const float* bPtr = bVector;
++-
++- float32x4x4_t aVal0, aVal1;
++- float32x4x2_t bVal0, bVal1;
++-
++- const unsigned int sixteenthPoints = num_points / 16;
++- unsigned int number = 0;
++- for(; number < sixteenthPoints; number++){
++- aVal0 = vld4q_f32((const float*)aPtr);
++- aPtr += 8;
++- aVal1 = vld4q_f32((const float*)aPtr);
++- aPtr += 8;
++- __VOLK_PREFETCH(aPtr+16);
++-
++- bVal0 = vld2q_f32((const float*)bPtr);
++- bPtr += 8;
++- bVal1 = vld2q_f32((const float*)bPtr);
++- bPtr += 8;
++- __VOLK_PREFETCH(bPtr+16);
++-
++- aVal0.val[0] = vaddq_f32(aVal0.val[0], bVal0.val[0]);
++- aVal0.val[2] = vaddq_f32(aVal0.val[2], bVal0.val[1]);
++-
++- aVal1.val[2] = vaddq_f32(aVal1.val[2], bVal1.val[1]);
++- aVal1.val[0] = vaddq_f32(aVal1.val[0], bVal1.val[0]);
++-
++- vst4q_f32((float*)(cPtr), aVal0);
++- cPtr += 8;
++- vst4q_f32((float*)(cPtr), aVal1);
++- cPtr += 8;
++- }
++-
++- for(number = sixteenthPoints * 16; number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const float* bPtr = bVector;
+++
+++ float32x4x4_t aVal0, aVal1;
+++ float32x4x2_t bVal0, bVal1;
+++
+++ const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ for (; number < sixteenthPoints; number++) {
+++ aVal0 = vld4q_f32((const float*)aPtr);
+++ aPtr += 8;
+++ aVal1 = vld4q_f32((const float*)aPtr);
+++ aPtr += 8;
+++ __VOLK_PREFETCH(aPtr + 16);
+++
+++ bVal0 = vld2q_f32((const float*)bPtr);
+++ bPtr += 8;
+++ bVal1 = vld2q_f32((const float*)bPtr);
+++ bPtr += 8;
+++ __VOLK_PREFETCH(bPtr + 16);
+++
+++ aVal0.val[0] = vaddq_f32(aVal0.val[0], bVal0.val[0]);
+++ aVal0.val[2] = vaddq_f32(aVal0.val[2], bVal0.val[1]);
+++
+++ aVal1.val[2] = vaddq_f32(aVal1.val[2], bVal1.val[1]);
+++ aVal1.val[0] = vaddq_f32(aVal1.val[0], bVal1.val[0]);
+++
+++ vst4q_f32((float*)(cPtr), aVal0);
+++ cPtr += 8;
+++ vst4q_f32((float*)(cPtr), aVal1);
+++ cPtr += 8;
+++ }
+++
+++ for (number = sixteenthPoints * 16; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++diff --git a/kernels/volk/volk_32fc_32f_dot_prod_32fc.h b/kernels/volk/volk_32fc_32f_dot_prod_32fc.h
++index 35f7077..d905870 100644
++--- a/kernels/volk/volk_32fc_32f_dot_prod_32fc.h
+++++ b/kernels/volk/volk_32fc_32f_dot_prod_32fc.h
++@@ -33,8 +33,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_32f_dot_prod_32fc(lv_32fc_t* result, const lv_32fc_t* input, const float * taps, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_32f_dot_prod_32fc(lv_32fc_t* result, const lv_32fc_t* input, const float
+++ * * taps, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li input: vector of complex samples
++@@ -63,28 +63,32 @@
++ #ifndef INCLUDED_volk_32fc_32f_dot_prod_32fc_a_H
++ #define INCLUDED_volk_32fc_32f_dot_prod_32fc_a_H
++
++-#include <volk/volk_common.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32fc_32f_dot_prod_32fc_generic(lv_32fc_t* result, const lv_32fc_t* input, const float * taps, unsigned int num_points) {
+++static inline void volk_32fc_32f_dot_prod_32fc_generic(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
++
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const float* aPtr = (float*)input;
++- const float* bPtr= taps;
++- unsigned int number = 0;
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const float* aPtr = (float*)input;
+++ const float* bPtr = taps;
+++ unsigned int number = 0;
++
++- *realpt = 0;
++- *imagpt = 0;
+++ *realpt = 0;
+++ *imagpt = 0;
++
++- for(number = 0; number < num_points; number++){
++- *realpt += ((*aPtr++) * (*bPtr));
++- *imagpt += ((*aPtr++) * (*bPtr++));
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *realpt += ((*aPtr++) * (*bPtr));
+++ *imagpt += ((*aPtr++) * (*bPtr++));
+++ }
++
++- *result = *(lv_32fc_t*)(&res[0]);
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -93,78 +97,83 @@ static inline void volk_32fc_32f_dot_prod_32fc_generic(lv_32fc_t* result, const
++
++ #include <immintrin.h>
++
++-static inline void volk_32fc_32f_dot_prod_32fc_a_avx2_fma( lv_32fc_t* result, const lv_32fc_t* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const float* aPtr = (float*)input;
++- const float* bPtr = taps;
++-
++- __m256 a0Val, a1Val, a2Val, a3Val;
++- __m256 b0Val, b1Val, b2Val, b3Val;
++- __m256 x0Val, x1Val, x0loVal, x0hiVal, x1loVal, x1hiVal;
++-
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
++- __m256 dotProdVal2 = _mm256_setzero_ps();
++- __m256 dotProdVal3 = _mm256_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- a0Val = _mm256_load_ps(aPtr);
++- a1Val = _mm256_load_ps(aPtr+8);
++- a2Val = _mm256_load_ps(aPtr+16);
++- a3Val = _mm256_load_ps(aPtr+24);
++-
++- x0Val = _mm256_load_ps(bPtr); // t0|t1|t2|t3|t4|t5|t6|t7
++- x1Val = _mm256_load_ps(bPtr+8);
++- x0loVal = _mm256_unpacklo_ps(x0Val, x0Val); // t0|t0|t1|t1|t4|t4|t5|t5
++- x0hiVal = _mm256_unpackhi_ps(x0Val, x0Val); // t2|t2|t3|t3|t6|t6|t7|t7
++- x1loVal = _mm256_unpacklo_ps(x1Val, x1Val);
++- x1hiVal = _mm256_unpackhi_ps(x1Val, x1Val);
++-
++- // TODO: it may be possible to rearrange swizzling to better pipeline data
++- b0Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x20); // t0|t0|t1|t1|t2|t2|t3|t3
++- b1Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x31); // t4|t4|t5|t5|t6|t6|t7|t7
++- b2Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x20);
++- b3Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x31);
++-
++- dotProdVal0 = _mm256_fmadd_ps(a0Val, b0Val, dotProdVal0);
++- dotProdVal1 = _mm256_fmadd_ps(a1Val, b1Val, dotProdVal1);
++- dotProdVal2 = _mm256_fmadd_ps(a2Val, b2Val, dotProdVal2);
++- dotProdVal3 = _mm256_fmadd_ps(a3Val, b3Val, dotProdVal3);
++-
++- aPtr += 32;
++- bPtr += 16;
++- }
++-
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++-
++- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- *realpt = dotProductVector[0];
++- *imagpt = dotProductVector[1];
++- *realpt += dotProductVector[2];
++- *imagpt += dotProductVector[3];
++- *realpt += dotProductVector[4];
++- *imagpt += dotProductVector[5];
++- *realpt += dotProductVector[6];
++- *imagpt += dotProductVector[7];
++-
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- *realpt += ((*aPtr++) * (*bPtr));
++- *imagpt += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = *(lv_32fc_t*)(&res[0]);
+++static inline void volk_32fc_32f_dot_prod_32fc_a_avx2_fma(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const float* aPtr = (float*)input;
+++ const float* bPtr = taps;
+++
+++ __m256 a0Val, a1Val, a2Val, a3Val;
+++ __m256 b0Val, b1Val, b2Val, b3Val;
+++ __m256 x0Val, x1Val, x0loVal, x0hiVal, x1loVal, x1hiVal;
+++
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 dotProdVal2 = _mm256_setzero_ps();
+++ __m256 dotProdVal3 = _mm256_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ a0Val = _mm256_load_ps(aPtr);
+++ a1Val = _mm256_load_ps(aPtr + 8);
+++ a2Val = _mm256_load_ps(aPtr + 16);
+++ a3Val = _mm256_load_ps(aPtr + 24);
+++
+++ x0Val = _mm256_load_ps(bPtr); // t0|t1|t2|t3|t4|t5|t6|t7
+++ x1Val = _mm256_load_ps(bPtr + 8);
+++ x0loVal = _mm256_unpacklo_ps(x0Val, x0Val); // t0|t0|t1|t1|t4|t4|t5|t5
+++ x0hiVal = _mm256_unpackhi_ps(x0Val, x0Val); // t2|t2|t3|t3|t6|t6|t7|t7
+++ x1loVal = _mm256_unpacklo_ps(x1Val, x1Val);
+++ x1hiVal = _mm256_unpackhi_ps(x1Val, x1Val);
+++
+++ // TODO: it may be possible to rearrange swizzling to better pipeline data
+++ b0Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x20); // t0|t0|t1|t1|t2|t2|t3|t3
+++ b1Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x31); // t4|t4|t5|t5|t6|t6|t7|t7
+++ b2Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x20);
+++ b3Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x31);
+++
+++ dotProdVal0 = _mm256_fmadd_ps(a0Val, b0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_fmadd_ps(a1Val, b1Val, dotProdVal1);
+++ dotProdVal2 = _mm256_fmadd_ps(a2Val, b2Val, dotProdVal2);
+++ dotProdVal3 = _mm256_fmadd_ps(a3Val, b3Val, dotProdVal3);
+++
+++ aPtr += 32;
+++ bPtr += 16;
+++ }
+++
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ *realpt = dotProductVector[0];
+++ *imagpt = dotProductVector[1];
+++ *realpt += dotProductVector[2];
+++ *imagpt += dotProductVector[3];
+++ *realpt += dotProductVector[4];
+++ *imagpt += dotProductVector[5];
+++ *realpt += dotProductVector[6];
+++ *imagpt += dotProductVector[7];
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *realpt += ((*aPtr++) * (*bPtr));
+++ *imagpt += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++ #endif /*LV_HAVE_AVX2 && LV_HAVE_FMA*/
++@@ -173,164 +182,172 @@ static inline void volk_32fc_32f_dot_prod_32fc_a_avx2_fma( lv_32fc_t* result, co
++
++ #include <immintrin.h>
++
++-static inline void volk_32fc_32f_dot_prod_32fc_a_avx( lv_32fc_t* result, const lv_32fc_t* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const float* aPtr = (float*)input;
++- const float* bPtr = taps;
++-
++- __m256 a0Val, a1Val, a2Val, a3Val;
++- __m256 b0Val, b1Val, b2Val, b3Val;
++- __m256 x0Val, x1Val, x0loVal, x0hiVal, x1loVal, x1hiVal;
++- __m256 c0Val, c1Val, c2Val, c3Val;
++-
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
++- __m256 dotProdVal2 = _mm256_setzero_ps();
++- __m256 dotProdVal3 = _mm256_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- a0Val = _mm256_load_ps(aPtr);
++- a1Val = _mm256_load_ps(aPtr+8);
++- a2Val = _mm256_load_ps(aPtr+16);
++- a3Val = _mm256_load_ps(aPtr+24);
++-
++- x0Val = _mm256_load_ps(bPtr); // t0|t1|t2|t3|t4|t5|t6|t7
++- x1Val = _mm256_load_ps(bPtr+8);
++- x0loVal = _mm256_unpacklo_ps(x0Val, x0Val); // t0|t0|t1|t1|t4|t4|t5|t5
++- x0hiVal = _mm256_unpackhi_ps(x0Val, x0Val); // t2|t2|t3|t3|t6|t6|t7|t7
++- x1loVal = _mm256_unpacklo_ps(x1Val, x1Val);
++- x1hiVal = _mm256_unpackhi_ps(x1Val, x1Val);
++-
++- // TODO: it may be possible to rearrange swizzling to better pipeline data
++- b0Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x20); // t0|t0|t1|t1|t2|t2|t3|t3
++- b1Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x31); // t4|t4|t5|t5|t6|t6|t7|t7
++- b2Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x20);
++- b3Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x31);
++-
++- c0Val = _mm256_mul_ps(a0Val, b0Val);
++- c1Val = _mm256_mul_ps(a1Val, b1Val);
++- c2Val = _mm256_mul_ps(a2Val, b2Val);
++- c3Val = _mm256_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm256_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm256_add_ps(c3Val, dotProdVal3);
++-
++- aPtr += 32;
++- bPtr += 16;
++- }
++-
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++-
++- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- *realpt = dotProductVector[0];
++- *imagpt = dotProductVector[1];
++- *realpt += dotProductVector[2];
++- *imagpt += dotProductVector[3];
++- *realpt += dotProductVector[4];
++- *imagpt += dotProductVector[5];
++- *realpt += dotProductVector[6];
++- *imagpt += dotProductVector[7];
++-
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- *realpt += ((*aPtr++) * (*bPtr));
++- *imagpt += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = *(lv_32fc_t*)(&res[0]);
+++static inline void volk_32fc_32f_dot_prod_32fc_a_avx(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const float* aPtr = (float*)input;
+++ const float* bPtr = taps;
+++
+++ __m256 a0Val, a1Val, a2Val, a3Val;
+++ __m256 b0Val, b1Val, b2Val, b3Val;
+++ __m256 x0Val, x1Val, x0loVal, x0hiVal, x1loVal, x1hiVal;
+++ __m256 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 dotProdVal2 = _mm256_setzero_ps();
+++ __m256 dotProdVal3 = _mm256_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ a0Val = _mm256_load_ps(aPtr);
+++ a1Val = _mm256_load_ps(aPtr + 8);
+++ a2Val = _mm256_load_ps(aPtr + 16);
+++ a3Val = _mm256_load_ps(aPtr + 24);
+++
+++ x0Val = _mm256_load_ps(bPtr); // t0|t1|t2|t3|t4|t5|t6|t7
+++ x1Val = _mm256_load_ps(bPtr + 8);
+++ x0loVal = _mm256_unpacklo_ps(x0Val, x0Val); // t0|t0|t1|t1|t4|t4|t5|t5
+++ x0hiVal = _mm256_unpackhi_ps(x0Val, x0Val); // t2|t2|t3|t3|t6|t6|t7|t7
+++ x1loVal = _mm256_unpacklo_ps(x1Val, x1Val);
+++ x1hiVal = _mm256_unpackhi_ps(x1Val, x1Val);
+++
+++ // TODO: it may be possible to rearrange swizzling to better pipeline data
+++ b0Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x20); // t0|t0|t1|t1|t2|t2|t3|t3
+++ b1Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x31); // t4|t4|t5|t5|t6|t6|t7|t7
+++ b2Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x20);
+++ b3Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x31);
+++
+++ c0Val = _mm256_mul_ps(a0Val, b0Val);
+++ c1Val = _mm256_mul_ps(a1Val, b1Val);
+++ c2Val = _mm256_mul_ps(a2Val, b2Val);
+++ c3Val = _mm256_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm256_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm256_add_ps(c3Val, dotProdVal3);
+++
+++ aPtr += 32;
+++ bPtr += 16;
+++ }
+++
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ *realpt = dotProductVector[0];
+++ *imagpt = dotProductVector[1];
+++ *realpt += dotProductVector[2];
+++ *imagpt += dotProductVector[3];
+++ *realpt += dotProductVector[4];
+++ *imagpt += dotProductVector[5];
+++ *realpt += dotProductVector[6];
+++ *imagpt += dotProductVector[7];
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *realpt += ((*aPtr++) * (*bPtr));
+++ *imagpt += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++ #endif /*LV_HAVE_AVX*/
++
++
++-
++-
++ #ifdef LV_HAVE_SSE
++
++
++-static inline void volk_32fc_32f_dot_prod_32fc_a_sse( lv_32fc_t* result, const lv_32fc_t* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 8;
++-
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const float* aPtr = (float*)input;
++- const float* bPtr = taps;
++-
++- __m128 a0Val, a1Val, a2Val, a3Val;
++- __m128 b0Val, b1Val, b2Val, b3Val;
++- __m128 x0Val, x1Val, x2Val, x3Val;
++- __m128 c0Val, c1Val, c2Val, c3Val;
++-
++- __m128 dotProdVal0 = _mm_setzero_ps();
++- __m128 dotProdVal1 = _mm_setzero_ps();
++- __m128 dotProdVal2 = _mm_setzero_ps();
++- __m128 dotProdVal3 = _mm_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- a0Val = _mm_load_ps(aPtr);
++- a1Val = _mm_load_ps(aPtr+4);
++- a2Val = _mm_load_ps(aPtr+8);
++- a3Val = _mm_load_ps(aPtr+12);
++-
++- x0Val = _mm_load_ps(bPtr);
++- x1Val = _mm_load_ps(bPtr);
++- x2Val = _mm_load_ps(bPtr+4);
++- x3Val = _mm_load_ps(bPtr+4);
++- b0Val = _mm_unpacklo_ps(x0Val, x1Val);
++- b1Val = _mm_unpackhi_ps(x0Val, x1Val);
++- b2Val = _mm_unpacklo_ps(x2Val, x3Val);
++- b3Val = _mm_unpackhi_ps(x2Val, x3Val);
++-
++- c0Val = _mm_mul_ps(a0Val, b0Val);
++- c1Val = _mm_mul_ps(a1Val, b1Val);
++- c2Val = _mm_mul_ps(a2Val, b2Val);
++- c3Val = _mm_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
++-
++- aPtr += 16;
++- bPtr += 8;
++- }
++-
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
++-
++- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- *realpt = dotProductVector[0];
++- *imagpt = dotProductVector[1];
++- *realpt += dotProductVector[2];
++- *imagpt += dotProductVector[3];
++-
++- number = sixteenthPoints*8;
++- for(;number < num_points; number++){
++- *realpt += ((*aPtr++) * (*bPtr));
++- *imagpt += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = *(lv_32fc_t*)(&res[0]);
+++static inline void volk_32fc_32f_dot_prod_32fc_a_sse(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 8;
+++
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const float* aPtr = (float*)input;
+++ const float* bPtr = taps;
+++
+++ __m128 a0Val, a1Val, a2Val, a3Val;
+++ __m128 b0Val, b1Val, b2Val, b3Val;
+++ __m128 x0Val, x1Val, x2Val, x3Val;
+++ __m128 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m128 dotProdVal0 = _mm_setzero_ps();
+++ __m128 dotProdVal1 = _mm_setzero_ps();
+++ __m128 dotProdVal2 = _mm_setzero_ps();
+++ __m128 dotProdVal3 = _mm_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ a0Val = _mm_load_ps(aPtr);
+++ a1Val = _mm_load_ps(aPtr + 4);
+++ a2Val = _mm_load_ps(aPtr + 8);
+++ a3Val = _mm_load_ps(aPtr + 12);
+++
+++ x0Val = _mm_load_ps(bPtr);
+++ x1Val = _mm_load_ps(bPtr);
+++ x2Val = _mm_load_ps(bPtr + 4);
+++ x3Val = _mm_load_ps(bPtr + 4);
+++ b0Val = _mm_unpacklo_ps(x0Val, x1Val);
+++ b1Val = _mm_unpackhi_ps(x0Val, x1Val);
+++ b2Val = _mm_unpacklo_ps(x2Val, x3Val);
+++ b3Val = _mm_unpackhi_ps(x2Val, x3Val);
+++
+++ c0Val = _mm_mul_ps(a0Val, b0Val);
+++ c1Val = _mm_mul_ps(a1Val, b1Val);
+++ c2Val = _mm_mul_ps(a2Val, b2Val);
+++ c3Val = _mm_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
+++
+++ aPtr += 16;
+++ bPtr += 8;
+++ }
+++
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
+++
+++ _mm_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ *realpt = dotProductVector[0];
+++ *imagpt = dotProductVector[1];
+++ *realpt += dotProductVector[2];
+++ *imagpt += dotProductVector[3];
+++
+++ number = sixteenthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *realpt += ((*aPtr++) * (*bPtr));
+++ *imagpt += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++ #endif /*LV_HAVE_SSE*/
++@@ -339,78 +356,83 @@ static inline void volk_32fc_32f_dot_prod_32fc_a_sse( lv_32fc_t* result, const
++
++ #include <immintrin.h>
++
++-static inline void volk_32fc_32f_dot_prod_32fc_u_avx2_fma( lv_32fc_t* result, const lv_32fc_t* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const float* aPtr = (float*)input;
++- const float* bPtr = taps;
++-
++- __m256 a0Val, a1Val, a2Val, a3Val;
++- __m256 b0Val, b1Val, b2Val, b3Val;
++- __m256 x0Val, x1Val, x0loVal, x0hiVal, x1loVal, x1hiVal;
++-
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
++- __m256 dotProdVal2 = _mm256_setzero_ps();
++- __m256 dotProdVal3 = _mm256_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- a0Val = _mm256_loadu_ps(aPtr);
++- a1Val = _mm256_loadu_ps(aPtr+8);
++- a2Val = _mm256_loadu_ps(aPtr+16);
++- a3Val = _mm256_loadu_ps(aPtr+24);
++-
++- x0Val = _mm256_load_ps(bPtr); // t0|t1|t2|t3|t4|t5|t6|t7
++- x1Val = _mm256_load_ps(bPtr+8);
++- x0loVal = _mm256_unpacklo_ps(x0Val, x0Val); // t0|t0|t1|t1|t4|t4|t5|t5
++- x0hiVal = _mm256_unpackhi_ps(x0Val, x0Val); // t2|t2|t3|t3|t6|t6|t7|t7
++- x1loVal = _mm256_unpacklo_ps(x1Val, x1Val);
++- x1hiVal = _mm256_unpackhi_ps(x1Val, x1Val);
++-
++- // TODO: it may be possible to rearrange swizzling to better pipeline data
++- b0Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x20); // t0|t0|t1|t1|t2|t2|t3|t3
++- b1Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x31); // t4|t4|t5|t5|t6|t6|t7|t7
++- b2Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x20);
++- b3Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x31);
++-
++- dotProdVal0 = _mm256_fmadd_ps(a0Val, b0Val, dotProdVal0);
++- dotProdVal1 = _mm256_fmadd_ps(a1Val, b1Val, dotProdVal1);
++- dotProdVal2 = _mm256_fmadd_ps(a2Val, b2Val, dotProdVal2);
++- dotProdVal3 = _mm256_fmadd_ps(a3Val, b3Val, dotProdVal3);
++-
++- aPtr += 32;
++- bPtr += 16;
++- }
++-
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++-
++- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- *realpt = dotProductVector[0];
++- *imagpt = dotProductVector[1];
++- *realpt += dotProductVector[2];
++- *imagpt += dotProductVector[3];
++- *realpt += dotProductVector[4];
++- *imagpt += dotProductVector[5];
++- *realpt += dotProductVector[6];
++- *imagpt += dotProductVector[7];
++-
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- *realpt += ((*aPtr++) * (*bPtr));
++- *imagpt += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = *(lv_32fc_t*)(&res[0]);
+++static inline void volk_32fc_32f_dot_prod_32fc_u_avx2_fma(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const float* aPtr = (float*)input;
+++ const float* bPtr = taps;
+++
+++ __m256 a0Val, a1Val, a2Val, a3Val;
+++ __m256 b0Val, b1Val, b2Val, b3Val;
+++ __m256 x0Val, x1Val, x0loVal, x0hiVal, x1loVal, x1hiVal;
+++
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 dotProdVal2 = _mm256_setzero_ps();
+++ __m256 dotProdVal3 = _mm256_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ a0Val = _mm256_loadu_ps(aPtr);
+++ a1Val = _mm256_loadu_ps(aPtr + 8);
+++ a2Val = _mm256_loadu_ps(aPtr + 16);
+++ a3Val = _mm256_loadu_ps(aPtr + 24);
+++
+++ x0Val = _mm256_load_ps(bPtr); // t0|t1|t2|t3|t4|t5|t6|t7
+++ x1Val = _mm256_load_ps(bPtr + 8);
+++ x0loVal = _mm256_unpacklo_ps(x0Val, x0Val); // t0|t0|t1|t1|t4|t4|t5|t5
+++ x0hiVal = _mm256_unpackhi_ps(x0Val, x0Val); // t2|t2|t3|t3|t6|t6|t7|t7
+++ x1loVal = _mm256_unpacklo_ps(x1Val, x1Val);
+++ x1hiVal = _mm256_unpackhi_ps(x1Val, x1Val);
+++
+++ // TODO: it may be possible to rearrange swizzling to better pipeline data
+++ b0Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x20); // t0|t0|t1|t1|t2|t2|t3|t3
+++ b1Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x31); // t4|t4|t5|t5|t6|t6|t7|t7
+++ b2Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x20);
+++ b3Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x31);
+++
+++ dotProdVal0 = _mm256_fmadd_ps(a0Val, b0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_fmadd_ps(a1Val, b1Val, dotProdVal1);
+++ dotProdVal2 = _mm256_fmadd_ps(a2Val, b2Val, dotProdVal2);
+++ dotProdVal3 = _mm256_fmadd_ps(a3Val, b3Val, dotProdVal3);
+++
+++ aPtr += 32;
+++ bPtr += 16;
+++ }
+++
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ *realpt = dotProductVector[0];
+++ *imagpt = dotProductVector[1];
+++ *realpt += dotProductVector[2];
+++ *imagpt += dotProductVector[3];
+++ *realpt += dotProductVector[4];
+++ *imagpt += dotProductVector[5];
+++ *realpt += dotProductVector[6];
+++ *imagpt += dotProductVector[7];
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *realpt += ((*aPtr++) * (*bPtr));
+++ *imagpt += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++ #endif /*LV_HAVE_AVX2 && LV_HAVE_FMA*/
++@@ -419,162 +441,172 @@ static inline void volk_32fc_32f_dot_prod_32fc_u_avx2_fma( lv_32fc_t* result, co
++
++ #include <immintrin.h>
++
++-static inline void volk_32fc_32f_dot_prod_32fc_u_avx( lv_32fc_t* result, const lv_32fc_t* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const float* aPtr = (float*)input;
++- const float* bPtr = taps;
++-
++- __m256 a0Val, a1Val, a2Val, a3Val;
++- __m256 b0Val, b1Val, b2Val, b3Val;
++- __m256 x0Val, x1Val, x0loVal, x0hiVal, x1loVal, x1hiVal;
++- __m256 c0Val, c1Val, c2Val, c3Val;
++-
++- __m256 dotProdVal0 = _mm256_setzero_ps();
++- __m256 dotProdVal1 = _mm256_setzero_ps();
++- __m256 dotProdVal2 = _mm256_setzero_ps();
++- __m256 dotProdVal3 = _mm256_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- a0Val = _mm256_loadu_ps(aPtr);
++- a1Val = _mm256_loadu_ps(aPtr+8);
++- a2Val = _mm256_loadu_ps(aPtr+16);
++- a3Val = _mm256_loadu_ps(aPtr+24);
++-
++- x0Val = _mm256_loadu_ps(bPtr); // t0|t1|t2|t3|t4|t5|t6|t7
++- x1Val = _mm256_loadu_ps(bPtr+8);
++- x0loVal = _mm256_unpacklo_ps(x0Val, x0Val); // t0|t0|t1|t1|t4|t4|t5|t5
++- x0hiVal = _mm256_unpackhi_ps(x0Val, x0Val); // t2|t2|t3|t3|t6|t6|t7|t7
++- x1loVal = _mm256_unpacklo_ps(x1Val, x1Val);
++- x1hiVal = _mm256_unpackhi_ps(x1Val, x1Val);
++-
++- // TODO: it may be possible to rearrange swizzling to better pipeline data
++- b0Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x20); // t0|t0|t1|t1|t2|t2|t3|t3
++- b1Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x31); // t4|t4|t5|t5|t6|t6|t7|t7
++- b2Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x20);
++- b3Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x31);
++-
++- c0Val = _mm256_mul_ps(a0Val, b0Val);
++- c1Val = _mm256_mul_ps(a1Val, b1Val);
++- c2Val = _mm256_mul_ps(a2Val, b2Val);
++- c3Val = _mm256_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm256_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm256_add_ps(c3Val, dotProdVal3);
++-
++- aPtr += 32;
++- bPtr += 16;
++- }
++-
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
++-
++- _mm256_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- *realpt = dotProductVector[0];
++- *imagpt = dotProductVector[1];
++- *realpt += dotProductVector[2];
++- *imagpt += dotProductVector[3];
++- *realpt += dotProductVector[4];
++- *imagpt += dotProductVector[5];
++- *realpt += dotProductVector[6];
++- *imagpt += dotProductVector[7];
++-
++- number = sixteenthPoints*16;
++- for(;number < num_points; number++){
++- *realpt += ((*aPtr++) * (*bPtr));
++- *imagpt += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = *(lv_32fc_t*)(&res[0]);
+++static inline void volk_32fc_32f_dot_prod_32fc_u_avx(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const float* aPtr = (float*)input;
+++ const float* bPtr = taps;
+++
+++ __m256 a0Val, a1Val, a2Val, a3Val;
+++ __m256 b0Val, b1Val, b2Val, b3Val;
+++ __m256 x0Val, x1Val, x0loVal, x0hiVal, x1loVal, x1hiVal;
+++ __m256 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m256 dotProdVal0 = _mm256_setzero_ps();
+++ __m256 dotProdVal1 = _mm256_setzero_ps();
+++ __m256 dotProdVal2 = _mm256_setzero_ps();
+++ __m256 dotProdVal3 = _mm256_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ a0Val = _mm256_loadu_ps(aPtr);
+++ a1Val = _mm256_loadu_ps(aPtr + 8);
+++ a2Val = _mm256_loadu_ps(aPtr + 16);
+++ a3Val = _mm256_loadu_ps(aPtr + 24);
+++
+++ x0Val = _mm256_loadu_ps(bPtr); // t0|t1|t2|t3|t4|t5|t6|t7
+++ x1Val = _mm256_loadu_ps(bPtr + 8);
+++ x0loVal = _mm256_unpacklo_ps(x0Val, x0Val); // t0|t0|t1|t1|t4|t4|t5|t5
+++ x0hiVal = _mm256_unpackhi_ps(x0Val, x0Val); // t2|t2|t3|t3|t6|t6|t7|t7
+++ x1loVal = _mm256_unpacklo_ps(x1Val, x1Val);
+++ x1hiVal = _mm256_unpackhi_ps(x1Val, x1Val);
+++
+++ // TODO: it may be possible to rearrange swizzling to better pipeline data
+++ b0Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x20); // t0|t0|t1|t1|t2|t2|t3|t3
+++ b1Val = _mm256_permute2f128_ps(x0loVal, x0hiVal, 0x31); // t4|t4|t5|t5|t6|t6|t7|t7
+++ b2Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x20);
+++ b3Val = _mm256_permute2f128_ps(x1loVal, x1hiVal, 0x31);
+++
+++ c0Val = _mm256_mul_ps(a0Val, b0Val);
+++ c1Val = _mm256_mul_ps(a1Val, b1Val);
+++ c2Val = _mm256_mul_ps(a2Val, b2Val);
+++ c3Val = _mm256_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm256_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm256_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm256_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm256_add_ps(c3Val, dotProdVal3);
+++
+++ aPtr += 32;
+++ bPtr += 16;
+++ }
+++
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm256_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(32) float dotProductVector[8];
+++
+++ _mm256_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ *realpt = dotProductVector[0];
+++ *imagpt = dotProductVector[1];
+++ *realpt += dotProductVector[2];
+++ *imagpt += dotProductVector[3];
+++ *realpt += dotProductVector[4];
+++ *imagpt += dotProductVector[5];
+++ *realpt += dotProductVector[6];
+++ *imagpt += dotProductVector[7];
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *realpt += ((*aPtr++) * (*bPtr));
+++ *imagpt += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++ #endif /*LV_HAVE_AVX*/
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_32fc_32f_dot_prod_32fc_neon_unroll ( lv_32fc_t* __restrict result, const lv_32fc_t* __restrict input, const float* __restrict taps, unsigned int num_points) {
++-
++- unsigned int number;
++- const unsigned int quarterPoints = num_points / 8;
++-
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const float* inputPtr = (float*)input;
++- const float* tapsPtr = taps;
++- float zero[4] = {0.0f, 0.0f, 0.0f, 0.0f };
++- float accVector_real[4];
++- float accVector_imag[4];
++-
++- float32x4x2_t inputVector0, inputVector1;
++- float32x4_t tapsVector0, tapsVector1;
++- float32x4_t tmp_real0, tmp_imag0;
++- float32x4_t tmp_real1, tmp_imag1;
++- float32x4_t real_accumulator0, imag_accumulator0;
++- float32x4_t real_accumulator1, imag_accumulator1;
++-
++- // zero out accumulators
++- // take a *float, return float32x4_t
++- real_accumulator0 = vld1q_f32( zero );
++- imag_accumulator0 = vld1q_f32( zero );
++- real_accumulator1 = vld1q_f32( zero );
++- imag_accumulator1 = vld1q_f32( zero );
++-
++- for(number=0 ;number < quarterPoints; number++){
++- // load doublewords and duplicate in to second lane
++- tapsVector0 = vld1q_f32(tapsPtr );
++- tapsVector1 = vld1q_f32(tapsPtr+4 );
++-
++- // load quadword of complex numbers in to 2 lanes. 1st lane is real, 2dn imag
++- inputVector0 = vld2q_f32(inputPtr );
++- inputVector1 = vld2q_f32(inputPtr+8 );
++- // inputVector is now a struct of two vectors, 0th is real, 1st is imag
++-
++- tmp_real0 = vmulq_f32(tapsVector0, inputVector0.val[0]);
++- tmp_imag0 = vmulq_f32(tapsVector0, inputVector0.val[1]);
++-
++- tmp_real1 = vmulq_f32(tapsVector1, inputVector1.val[0]);
++- tmp_imag1 = vmulq_f32(tapsVector1, inputVector1.val[1]);
++-
++- real_accumulator0 = vaddq_f32(real_accumulator0, tmp_real0);
++- imag_accumulator0 = vaddq_f32(imag_accumulator0, tmp_imag0);
++-
++- real_accumulator1 = vaddq_f32(real_accumulator1, tmp_real1);
++- imag_accumulator1 = vaddq_f32(imag_accumulator1, tmp_imag1);
++-
++- tapsPtr += 8;
++- inputPtr += 16;
++- }
++-
++- real_accumulator0 = vaddq_f32( real_accumulator0, real_accumulator1);
++- imag_accumulator0 = vaddq_f32( imag_accumulator0, imag_accumulator1);
++- // void vst1q_f32( float32_t * ptr, float32x4_t val);
++- // store results back to a complex (array of 2 floats)
++- vst1q_f32(accVector_real, real_accumulator0);
++- vst1q_f32(accVector_imag, imag_accumulator0);
++- *realpt = accVector_real[0] + accVector_real[1] +
++- accVector_real[2] + accVector_real[3] ;
++-
++- *imagpt = accVector_imag[0] + accVector_imag[1] +
++- accVector_imag[2] + accVector_imag[3] ;
++-
++- // clean up the remainder
++- for(number=quarterPoints*8; number < num_points; number++){
++- *realpt += ((*inputPtr++) * (*tapsPtr));
++- *imagpt += ((*inputPtr++) * (*tapsPtr++));
++- }
++-
++- *result = *(lv_32fc_t*)(&res[0]);
+++static inline void
+++volk_32fc_32f_dot_prod_32fc_neon_unroll(lv_32fc_t* __restrict result,
+++ const lv_32fc_t* __restrict input,
+++ const float* __restrict taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number;
+++ const unsigned int quarterPoints = num_points / 8;
+++
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const float* inputPtr = (float*)input;
+++ const float* tapsPtr = taps;
+++ float zero[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+++ float accVector_real[4];
+++ float accVector_imag[4];
+++
+++ float32x4x2_t inputVector0, inputVector1;
+++ float32x4_t tapsVector0, tapsVector1;
+++ float32x4_t tmp_real0, tmp_imag0;
+++ float32x4_t tmp_real1, tmp_imag1;
+++ float32x4_t real_accumulator0, imag_accumulator0;
+++ float32x4_t real_accumulator1, imag_accumulator1;
+++
+++ // zero out accumulators
+++ // take a *float, return float32x4_t
+++ real_accumulator0 = vld1q_f32(zero);
+++ imag_accumulator0 = vld1q_f32(zero);
+++ real_accumulator1 = vld1q_f32(zero);
+++ imag_accumulator1 = vld1q_f32(zero);
+++
+++ for (number = 0; number < quarterPoints; number++) {
+++ // load doublewords and duplicate in to second lane
+++ tapsVector0 = vld1q_f32(tapsPtr);
+++ tapsVector1 = vld1q_f32(tapsPtr + 4);
+++
+++ // load quadword of complex numbers in to 2 lanes. 1st lane is real, 2dn imag
+++ inputVector0 = vld2q_f32(inputPtr);
+++ inputVector1 = vld2q_f32(inputPtr + 8);
+++ // inputVector is now a struct of two vectors, 0th is real, 1st is imag
+++
+++ tmp_real0 = vmulq_f32(tapsVector0, inputVector0.val[0]);
+++ tmp_imag0 = vmulq_f32(tapsVector0, inputVector0.val[1]);
+++
+++ tmp_real1 = vmulq_f32(tapsVector1, inputVector1.val[0]);
+++ tmp_imag1 = vmulq_f32(tapsVector1, inputVector1.val[1]);
+++
+++ real_accumulator0 = vaddq_f32(real_accumulator0, tmp_real0);
+++ imag_accumulator0 = vaddq_f32(imag_accumulator0, tmp_imag0);
+++
+++ real_accumulator1 = vaddq_f32(real_accumulator1, tmp_real1);
+++ imag_accumulator1 = vaddq_f32(imag_accumulator1, tmp_imag1);
+++
+++ tapsPtr += 8;
+++ inputPtr += 16;
+++ }
+++
+++ real_accumulator0 = vaddq_f32(real_accumulator0, real_accumulator1);
+++ imag_accumulator0 = vaddq_f32(imag_accumulator0, imag_accumulator1);
+++ // void vst1q_f32( float32_t * ptr, float32x4_t val);
+++ // store results back to a complex (array of 2 floats)
+++ vst1q_f32(accVector_real, real_accumulator0);
+++ vst1q_f32(accVector_imag, imag_accumulator0);
+++ *realpt =
+++ accVector_real[0] + accVector_real[1] + accVector_real[2] + accVector_real[3];
+++
+++ *imagpt =
+++ accVector_imag[0] + accVector_imag[1] + accVector_imag[2] + accVector_imag[3];
+++
+++ // clean up the remainder
+++ for (number = quarterPoints * 8; number < num_points; number++) {
+++ *realpt += ((*inputPtr++) * (*tapsPtr));
+++ *imagpt += ((*inputPtr++) * (*tapsPtr++));
+++ }
+++
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++ #endif /*LV_HAVE_NEON*/
++@@ -582,154 +614,171 @@ static inline void volk_32fc_32f_dot_prod_32fc_neon_unroll ( lv_32fc_t* __restri
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_32fc_32f_dot_prod_32fc_a_neon ( lv_32fc_t* __restrict result, const lv_32fc_t* __restrict input, const float* __restrict taps, unsigned int num_points) {
++-
++- unsigned int number;
++- const unsigned int quarterPoints = num_points / 4;
+++static inline void volk_32fc_32f_dot_prod_32fc_a_neon(lv_32fc_t* __restrict result,
+++ const lv_32fc_t* __restrict input,
+++ const float* __restrict taps,
+++ unsigned int num_points)
+++{
++
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const float* inputPtr = (float*)input;
++- const float* tapsPtr = taps;
++- float zero[4] = {0.0f, 0.0f, 0.0f, 0.0f };
++- float accVector_real[4];
++- float accVector_imag[4];
+++ unsigned int number;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float32x4x2_t inputVector;
++- float32x4_t tapsVector;
++- float32x4_t tmp_real, tmp_imag;
++- float32x4_t real_accumulator, imag_accumulator;
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const float* inputPtr = (float*)input;
+++ const float* tapsPtr = taps;
+++ float zero[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+++ float accVector_real[4];
+++ float accVector_imag[4];
++
+++ float32x4x2_t inputVector;
+++ float32x4_t tapsVector;
+++ float32x4_t tmp_real, tmp_imag;
+++ float32x4_t real_accumulator, imag_accumulator;
++
++- // zero out accumulators
++- // take a *float, return float32x4_t
++- real_accumulator = vld1q_f32( zero );
++- imag_accumulator = vld1q_f32( zero );
++
++- for(number=0 ;number < quarterPoints; number++){
++- // load taps ( float32x2x2_t = vld1q_f32( float32_t const * ptr) )
++- // load doublewords and duplicate in to second lane
++- tapsVector = vld1q_f32(tapsPtr );
+++ // zero out accumulators
+++ // take a *float, return float32x4_t
+++ real_accumulator = vld1q_f32(zero);
+++ imag_accumulator = vld1q_f32(zero);
++
++- // load quadword of complex numbers in to 2 lanes. 1st lane is real, 2dn imag
++- inputVector = vld2q_f32(inputPtr );
+++ for (number = 0; number < quarterPoints; number++) {
+++ // load taps ( float32x2x2_t = vld1q_f32( float32_t const * ptr) )
+++ // load doublewords and duplicate in to second lane
+++ tapsVector = vld1q_f32(tapsPtr);
++
++- tmp_real = vmulq_f32(tapsVector, inputVector.val[0]);
++- tmp_imag = vmulq_f32(tapsVector, inputVector.val[1]);
+++ // load quadword of complex numbers in to 2 lanes. 1st lane is real, 2dn imag
+++ inputVector = vld2q_f32(inputPtr);
++
++- real_accumulator = vaddq_f32(real_accumulator, tmp_real);
++- imag_accumulator = vaddq_f32(imag_accumulator, tmp_imag);
+++ tmp_real = vmulq_f32(tapsVector, inputVector.val[0]);
+++ tmp_imag = vmulq_f32(tapsVector, inputVector.val[1]);
++
+++ real_accumulator = vaddq_f32(real_accumulator, tmp_real);
+++ imag_accumulator = vaddq_f32(imag_accumulator, tmp_imag);
++
++- tapsPtr += 4;
++- inputPtr += 8;
++
++- }
+++ tapsPtr += 4;
+++ inputPtr += 8;
+++ }
++
++- // store results back to a complex (array of 2 floats)
++- vst1q_f32(accVector_real, real_accumulator);
++- vst1q_f32(accVector_imag, imag_accumulator);
++- *realpt = accVector_real[0] + accVector_real[1] +
++- accVector_real[2] + accVector_real[3] ;
+++ // store results back to a complex (array of 2 floats)
+++ vst1q_f32(accVector_real, real_accumulator);
+++ vst1q_f32(accVector_imag, imag_accumulator);
+++ *realpt =
+++ accVector_real[0] + accVector_real[1] + accVector_real[2] + accVector_real[3];
++
++- *imagpt = accVector_imag[0] + accVector_imag[1] +
++- accVector_imag[2] + accVector_imag[3] ;
+++ *imagpt =
+++ accVector_imag[0] + accVector_imag[1] + accVector_imag[2] + accVector_imag[3];
++
++- // clean up the remainder
++- for(number=quarterPoints*4; number < num_points; number++){
++- *realpt += ((*inputPtr++) * (*tapsPtr));
++- *imagpt += ((*inputPtr++) * (*tapsPtr++));
++- }
+++ // clean up the remainder
+++ for (number = quarterPoints * 4; number < num_points; number++) {
+++ *realpt += ((*inputPtr++) * (*tapsPtr));
+++ *imagpt += ((*inputPtr++) * (*tapsPtr++));
+++ }
++
++- *result = *(lv_32fc_t*)(&res[0]);
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++ #endif /*LV_HAVE_NEON*/
++
++ #ifdef LV_HAVE_NEONV7
++-extern void volk_32fc_32f_dot_prod_32fc_a_neonasm ( lv_32fc_t* result, const lv_32fc_t* input, const float* taps, unsigned int num_points);
+++extern void volk_32fc_32f_dot_prod_32fc_a_neonasm(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const float* taps,
+++ unsigned int num_points);
++ #endif /*LV_HAVE_NEONV7*/
++
++ #ifdef LV_HAVE_NEONV7
++-extern void volk_32fc_32f_dot_prod_32fc_a_neonasmvmla ( lv_32fc_t* result, const lv_32fc_t* input, const float* taps, unsigned int num_points);
+++extern void volk_32fc_32f_dot_prod_32fc_a_neonasmvmla(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const float* taps,
+++ unsigned int num_points);
++ #endif /*LV_HAVE_NEONV7*/
++
++ #ifdef LV_HAVE_NEONV7
++-extern void volk_32fc_32f_dot_prod_32fc_a_neonpipeline ( lv_32fc_t* result, const lv_32fc_t* input, const float* taps, unsigned int num_points);
+++extern void volk_32fc_32f_dot_prod_32fc_a_neonpipeline(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const float* taps,
+++ unsigned int num_points);
++ #endif /*LV_HAVE_NEONV7*/
++
++ #ifdef LV_HAVE_SSE
++
++-static inline void volk_32fc_32f_dot_prod_32fc_u_sse( lv_32fc_t* result, const lv_32fc_t* input, const float* taps, unsigned int num_points) {
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 8;
++-
++- float res[2];
++- float *realpt = &res[0], *imagpt = &res[1];
++- const float* aPtr = (float*)input;
++- const float* bPtr = taps;
++-
++- __m128 a0Val, a1Val, a2Val, a3Val;
++- __m128 b0Val, b1Val, b2Val, b3Val;
++- __m128 x0Val, x1Val, x2Val, x3Val;
++- __m128 c0Val, c1Val, c2Val, c3Val;
++-
++- __m128 dotProdVal0 = _mm_setzero_ps();
++- __m128 dotProdVal1 = _mm_setzero_ps();
++- __m128 dotProdVal2 = _mm_setzero_ps();
++- __m128 dotProdVal3 = _mm_setzero_ps();
++-
++- for(;number < sixteenthPoints; number++){
++-
++- a0Val = _mm_loadu_ps(aPtr);
++- a1Val = _mm_loadu_ps(aPtr+4);
++- a2Val = _mm_loadu_ps(aPtr+8);
++- a3Val = _mm_loadu_ps(aPtr+12);
++-
++- x0Val = _mm_loadu_ps(bPtr);
++- x1Val = _mm_loadu_ps(bPtr);
++- x2Val = _mm_loadu_ps(bPtr+4);
++- x3Val = _mm_loadu_ps(bPtr+4);
++- b0Val = _mm_unpacklo_ps(x0Val, x1Val);
++- b1Val = _mm_unpackhi_ps(x0Val, x1Val);
++- b2Val = _mm_unpacklo_ps(x2Val, x3Val);
++- b3Val = _mm_unpackhi_ps(x2Val, x3Val);
++-
++- c0Val = _mm_mul_ps(a0Val, b0Val);
++- c1Val = _mm_mul_ps(a1Val, b1Val);
++- c2Val = _mm_mul_ps(a2Val, b2Val);
++- c3Val = _mm_mul_ps(a3Val, b3Val);
++-
++- dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
++- dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
++- dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
++- dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
++-
++- aPtr += 16;
++- bPtr += 8;
++- }
++-
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
++- dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
++-
++- __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
++-
++- _mm_store_ps(dotProductVector,dotProdVal0); // Store the results back into the dot product vector
++-
++- *realpt = dotProductVector[0];
++- *imagpt = dotProductVector[1];
++- *realpt += dotProductVector[2];
++- *imagpt += dotProductVector[3];
++-
++- number = sixteenthPoints*8;
++- for(;number < num_points; number++){
++- *realpt += ((*aPtr++) * (*bPtr));
++- *imagpt += ((*aPtr++) * (*bPtr++));
++- }
++-
++- *result = *(lv_32fc_t*)(&res[0]);
+++static inline void volk_32fc_32f_dot_prod_32fc_u_sse(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const float* taps,
+++ unsigned int num_points)
+++{
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 8;
+++
+++ float res[2];
+++ float *realpt = &res[0], *imagpt = &res[1];
+++ const float* aPtr = (float*)input;
+++ const float* bPtr = taps;
+++
+++ __m128 a0Val, a1Val, a2Val, a3Val;
+++ __m128 b0Val, b1Val, b2Val, b3Val;
+++ __m128 x0Val, x1Val, x2Val, x3Val;
+++ __m128 c0Val, c1Val, c2Val, c3Val;
+++
+++ __m128 dotProdVal0 = _mm_setzero_ps();
+++ __m128 dotProdVal1 = _mm_setzero_ps();
+++ __m128 dotProdVal2 = _mm_setzero_ps();
+++ __m128 dotProdVal3 = _mm_setzero_ps();
+++
+++ for (; number < sixteenthPoints; number++) {
+++
+++ a0Val = _mm_loadu_ps(aPtr);
+++ a1Val = _mm_loadu_ps(aPtr + 4);
+++ a2Val = _mm_loadu_ps(aPtr + 8);
+++ a3Val = _mm_loadu_ps(aPtr + 12);
+++
+++ x0Val = _mm_loadu_ps(bPtr);
+++ x1Val = _mm_loadu_ps(bPtr);
+++ x2Val = _mm_loadu_ps(bPtr + 4);
+++ x3Val = _mm_loadu_ps(bPtr + 4);
+++ b0Val = _mm_unpacklo_ps(x0Val, x1Val);
+++ b1Val = _mm_unpackhi_ps(x0Val, x1Val);
+++ b2Val = _mm_unpacklo_ps(x2Val, x3Val);
+++ b3Val = _mm_unpackhi_ps(x2Val, x3Val);
+++
+++ c0Val = _mm_mul_ps(a0Val, b0Val);
+++ c1Val = _mm_mul_ps(a1Val, b1Val);
+++ c2Val = _mm_mul_ps(a2Val, b2Val);
+++ c3Val = _mm_mul_ps(a3Val, b3Val);
+++
+++ dotProdVal0 = _mm_add_ps(c0Val, dotProdVal0);
+++ dotProdVal1 = _mm_add_ps(c1Val, dotProdVal1);
+++ dotProdVal2 = _mm_add_ps(c2Val, dotProdVal2);
+++ dotProdVal3 = _mm_add_ps(c3Val, dotProdVal3);
+++
+++ aPtr += 16;
+++ bPtr += 8;
+++ }
+++
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal1);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal2);
+++ dotProdVal0 = _mm_add_ps(dotProdVal0, dotProdVal3);
+++
+++ __VOLK_ATTR_ALIGNED(16) float dotProductVector[4];
+++
+++ _mm_store_ps(dotProductVector,
+++ dotProdVal0); // Store the results back into the dot product vector
+++
+++ *realpt = dotProductVector[0];
+++ *imagpt = dotProductVector[1];
+++ *realpt += dotProductVector[2];
+++ *imagpt += dotProductVector[3];
+++
+++ number = sixteenthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *realpt += ((*aPtr++) * (*bPtr));
+++ *imagpt += ((*aPtr++) * (*bPtr++));
+++ }
+++
+++ *result = *(lv_32fc_t*)(&res[0]);
++ }
++
++ #endif /*LV_HAVE_SSE*/
++diff --git a/kernels/volk/volk_32fc_32f_multiply_32fc.h b/kernels/volk/volk_32fc_32f_multiply_32fc.h
++index b47883f..196ba9a 100644
++--- a/kernels/volk/volk_32fc_32f_multiply_32fc.h
+++++ b/kernels/volk/volk_32fc_32f_multiply_32fc.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_32f_multiply_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float* bVector, unsigned int num_points);
++- * \endcode
+++ * void volk_32fc_32f_multiply_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const
+++ * float* bVector, unsigned int num_points); \endcode
++ *
++ * \b Inputs
++ * \li aVector: The input vector of complex floats.
++@@ -61,52 +61,55 @@
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_32f_multiply_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32fc_32f_multiply_32fc_a_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const float* bPtr= bVector;
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m256 aVal1, aVal2, bVal, bVal1, bVal2, cVal1, cVal2;
+++ __m256 aVal1, aVal2, bVal, bVal1, bVal2, cVal1, cVal2;
++
++- __m256i permute_mask = _mm256_set_epi32(3, 3, 2, 2, 1, 1, 0, 0);
+++ __m256i permute_mask = _mm256_set_epi32(3, 3, 2, 2, 1, 1, 0, 0);
++
++- for(;number < eighthPoints; number++){
+++ for (; number < eighthPoints; number++) {
++
++- aVal1 = _mm256_load_ps((float *)aPtr);
++- aPtr += 4;
+++ aVal1 = _mm256_load_ps((float*)aPtr);
+++ aPtr += 4;
++
++- aVal2 = _mm256_load_ps((float *)aPtr);
++- aPtr += 4;
+++ aVal2 = _mm256_load_ps((float*)aPtr);
+++ aPtr += 4;
++
++- bVal = _mm256_load_ps(bPtr); // b0|b1|b2|b3|b4|b5|b6|b7
++- bPtr += 8;
+++ bVal = _mm256_load_ps(bPtr); // b0|b1|b2|b3|b4|b5|b6|b7
+++ bPtr += 8;
++
++- bVal1 = _mm256_permute2f128_ps(bVal, bVal, 0x00); // b0|b1|b2|b3|b0|b1|b2|b3
++- bVal2 = _mm256_permute2f128_ps(bVal, bVal, 0x11); // b4|b5|b6|b7|b4|b5|b6|b7
+++ bVal1 = _mm256_permute2f128_ps(bVal, bVal, 0x00); // b0|b1|b2|b3|b0|b1|b2|b3
+++ bVal2 = _mm256_permute2f128_ps(bVal, bVal, 0x11); // b4|b5|b6|b7|b4|b5|b6|b7
++
++- bVal1 = _mm256_permutevar_ps(bVal1, permute_mask); // b0|b0|b1|b1|b2|b2|b3|b3
++- bVal2 = _mm256_permutevar_ps(bVal2, permute_mask); // b4|b4|b5|b5|b6|b6|b7|b7
+++ bVal1 = _mm256_permutevar_ps(bVal1, permute_mask); // b0|b0|b1|b1|b2|b2|b3|b3
+++ bVal2 = _mm256_permutevar_ps(bVal2, permute_mask); // b4|b4|b5|b5|b6|b6|b7|b7
++
++- cVal1 = _mm256_mul_ps(aVal1, bVal1);
++- cVal2 = _mm256_mul_ps(aVal2, bVal2);
+++ cVal1 = _mm256_mul_ps(aVal1, bVal1);
+++ cVal2 = _mm256_mul_ps(aVal2, bVal2);
++
++- _mm256_store_ps((float*)cPtr,cVal1); // Store the results back into the C container
++- cPtr += 4;
+++ _mm256_store_ps((float*)cPtr,
+++ cVal1); // Store the results back into the C container
+++ cPtr += 4;
++
++- _mm256_store_ps((float*)cPtr,cVal2); // Store the results back into the C container
++- cPtr += 4;
++- }
+++ _mm256_store_ps((float*)cPtr,
+++ cVal2); // Store the results back into the C container
+++ cPtr += 4;
+++ }
++
++- number = eighthPoints * 8;
++- for(;number < num_points; ++number){
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; ++number) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -114,67 +117,69 @@ volk_32fc_32f_multiply_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32fc_32f_multiply_32fc_a_sse(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32fc_32f_multiply_32fc_a_sse(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const float* bPtr= bVector;
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const float* bPtr = bVector;
++
++- __m128 aVal1, aVal2, bVal, bVal1, bVal2, cVal;
++- for(;number < quarterPoints; number++){
+++ __m128 aVal1, aVal2, bVal, bVal1, bVal2, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal1 = _mm_load_ps((const float*)aPtr);
++- aPtr += 2;
+++ aVal1 = _mm_load_ps((const float*)aPtr);
+++ aPtr += 2;
++
++- aVal2 = _mm_load_ps((const float*)aPtr);
++- aPtr += 2;
+++ aVal2 = _mm_load_ps((const float*)aPtr);
+++ aPtr += 2;
++
++- bVal = _mm_load_ps(bPtr);
++- bPtr += 4;
+++ bVal = _mm_load_ps(bPtr);
+++ bPtr += 4;
++
++- bVal1 = _mm_shuffle_ps(bVal, bVal, _MM_SHUFFLE(1,1,0,0));
++- bVal2 = _mm_shuffle_ps(bVal, bVal, _MM_SHUFFLE(3,3,2,2));
+++ bVal1 = _mm_shuffle_ps(bVal, bVal, _MM_SHUFFLE(1, 1, 0, 0));
+++ bVal2 = _mm_shuffle_ps(bVal, bVal, _MM_SHUFFLE(3, 3, 2, 2));
++
++- cVal = _mm_mul_ps(aVal1, bVal1);
+++ cVal = _mm_mul_ps(aVal1, bVal1);
++
++- _mm_store_ps((float*)cPtr,cVal); // Store the results back into the C container
++- cPtr += 2;
+++ _mm_store_ps((float*)cPtr, cVal); // Store the results back into the C container
+++ cPtr += 2;
++
++- cVal = _mm_mul_ps(aVal2, bVal2);
+++ cVal = _mm_mul_ps(aVal2, bVal2);
++
++- _mm_store_ps((float*)cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps((float*)cPtr, cVal); // Store the results back into the C container
++
++- cPtr += 2;
++- }
+++ cPtr += 2;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) * (*bPtr);
++- bPtr++;
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr);
+++ bPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_32f_multiply_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32fc_32f_multiply_32fc_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const float* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -182,49 +187,52 @@ volk_32fc_32f_multiply_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32fc_32f_multiply_32fc_neon(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32fc_32f_multiply_32fc_neon(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const float* bPtr= bVector;
++- unsigned int number = 0;
++- unsigned int quarter_points = num_points / 4;
++-
++- float32x4x2_t inputVector, outputVector;
++- float32x4_t tapsVector;
++- for(number = 0; number < quarter_points; number++){
++- inputVector = vld2q_f32((float*)aPtr);
++- tapsVector = vld1q_f32(bPtr);
++-
++- outputVector.val[0] = vmulq_f32(inputVector.val[0], tapsVector);
++- outputVector.val[1] = vmulq_f32(inputVector.val[1], tapsVector);
++-
++- vst2q_f32((float*)cPtr, outputVector);
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
++-
++- for(number = quarter_points * 4; number < num_points; number++){
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const float* bPtr = bVector;
+++ unsigned int number = 0;
+++ unsigned int quarter_points = num_points / 4;
+++
+++ float32x4x2_t inputVector, outputVector;
+++ float32x4_t tapsVector;
+++ for (number = 0; number < quarter_points; number++) {
+++ inputVector = vld2q_f32((float*)aPtr);
+++ tapsVector = vld1q_f32(bPtr);
+++
+++ outputVector.val[0] = vmulq_f32(inputVector.val[0], tapsVector);
+++ outputVector.val[1] = vmulq_f32(inputVector.val[1], tapsVector);
+++
+++ vst2q_f32((float*)cPtr, outputVector);
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_ORC
++
++-extern void
++-volk_32fc_32f_multiply_32fc_a_orc_impl(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const float* bVector, unsigned int num_points);
+++extern void volk_32fc_32f_multiply_32fc_a_orc_impl(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const float* bVector,
+++ unsigned int num_points);
++
++-static inline void
++-volk_32fc_32f_multiply_32fc_u_orc(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const float* bVector, unsigned int num_points)
+++static inline void volk_32fc_32f_multiply_32fc_u_orc(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const float* bVector,
+++ unsigned int num_points)
++ {
++- volk_32fc_32f_multiply_32fc_a_orc_impl(cVector, aVector, bVector, num_points);
+++ volk_32fc_32f_multiply_32fc_a_orc_impl(cVector, aVector, bVector, num_points);
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++diff --git a/kernels/volk/volk_32fc_conjugate_32fc.h b/kernels/volk/volk_32fc_conjugate_32fc.h
++index 6994d0e..9195e3a 100644
++--- a/kernels/volk/volk_32fc_conjugate_32fc.h
+++++ b/kernels/volk/volk_32fc_conjugate_32fc.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_conjugate_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_conjugate_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, unsigned
+++ * int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: The input vector of complex floats.
++@@ -68,91 +68,94 @@
++ #ifndef INCLUDED_volk_32fc_conjugate_32fc_u_H
++ #define INCLUDED_volk_32fc_conjugate_32fc_u_H
++
+++#include <float.h>
++ #include <inttypes.h>
++ #include <stdio.h>
++ #include <volk/volk_complex.h>
++-#include <float.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_conjugate_32fc_u_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector, unsigned int num_points)
+++static inline void volk_32fc_conjugate_32fc_u_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- __m256 x;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
+++ __m256 x;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
++
++- __m256 conjugator = _mm256_setr_ps(0, -0.f, 0, -0.f, 0, -0.f, 0, -0.f);
+++ __m256 conjugator = _mm256_setr_ps(0, -0.f, 0, -0.f, 0, -0.f, 0, -0.f);
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- x = _mm256_loadu_ps((float*)a); // Load the complex data as ar,ai,br,bi
+++ x = _mm256_loadu_ps((float*)a); // Load the complex data as ar,ai,br,bi
++
++- x = _mm256_xor_ps(x, conjugator); // conjugate register
+++ x = _mm256_xor_ps(x, conjugator); // conjugate register
++
++- _mm256_storeu_ps((float*)c,x); // Store the results back into the C container
+++ _mm256_storeu_ps((float*)c, x); // Store the results back into the C container
++
++- a += 4;
++- c += 4;
++- }
+++ a += 4;
+++ c += 4;
+++ }
++
++- number = quarterPoints * 4;
+++ number = quarterPoints * 4;
++
++- for(;number < num_points; number++) {
++- *c++ = lv_conj(*a++);
++- }
+++ for (; number < num_points; number++) {
+++ *c++ = lv_conj(*a++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE3
++ #include <pmmintrin.h>
++
++-static inline void
++-volk_32fc_conjugate_32fc_u_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector, unsigned int num_points)
+++static inline void volk_32fc_conjugate_32fc_u_sse3(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int halfPoints = num_points / 2;
+++ unsigned int number = 0;
+++ const unsigned int halfPoints = num_points / 2;
++
++- __m128 x;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
+++ __m128 x;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
++
++- __m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);
+++ __m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);
++
++- for(;number < halfPoints; number++){
+++ for (; number < halfPoints; number++) {
++
++- x = _mm_loadu_ps((float*)a); // Load the complex data as ar,ai,br,bi
+++ x = _mm_loadu_ps((float*)a); // Load the complex data as ar,ai,br,bi
++
++- x = _mm_xor_ps(x, conjugator); // conjugate register
+++ x = _mm_xor_ps(x, conjugator); // conjugate register
++
++- _mm_storeu_ps((float*)c,x); // Store the results back into the C container
+++ _mm_storeu_ps((float*)c, x); // Store the results back into the C container
++
++- a += 2;
++- c += 2;
++- }
+++ a += 2;
+++ c += 2;
+++ }
++
++- if((num_points % 2) != 0) {
++- *c = lv_conj(*a);
++- }
+++ if ((num_points % 2) != 0) {
+++ *c = lv_conj(*a);
+++ }
++ }
++ #endif /* LV_HAVE_SSE3 */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_conjugate_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, unsigned int num_points)
+++static inline void volk_32fc_conjugate_32fc_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- unsigned int number = 0;
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = lv_conj(*aPtr++);
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = lv_conj(*aPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -161,124 +164,128 @@ volk_32fc_conjugate_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, u
++ #ifndef INCLUDED_volk_32fc_conjugate_32fc_a_H
++ #define INCLUDED_volk_32fc_conjugate_32fc_a_H
++
+++#include <float.h>
++ #include <inttypes.h>
++ #include <stdio.h>
++ #include <volk/volk_complex.h>
++-#include <float.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_conjugate_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector, unsigned int num_points)
+++static inline void volk_32fc_conjugate_32fc_a_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- __m256 x;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
+++ __m256 x;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
++
++- __m256 conjugator = _mm256_setr_ps(0, -0.f, 0, -0.f, 0, -0.f, 0, -0.f);
+++ __m256 conjugator = _mm256_setr_ps(0, -0.f, 0, -0.f, 0, -0.f, 0, -0.f);
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- x = _mm256_load_ps((float*)a); // Load the complex data as ar,ai,br,bi
+++ x = _mm256_load_ps((float*)a); // Load the complex data as ar,ai,br,bi
++
++- x = _mm256_xor_ps(x, conjugator); // conjugate register
+++ x = _mm256_xor_ps(x, conjugator); // conjugate register
++
++- _mm256_store_ps((float*)c,x); // Store the results back into the C container
+++ _mm256_store_ps((float*)c, x); // Store the results back into the C container
++
++- a += 4;
++- c += 4;
++- }
+++ a += 4;
+++ c += 4;
+++ }
++
++- number = quarterPoints * 4;
+++ number = quarterPoints * 4;
++
++- for(;number < num_points; number++) {
++- *c++ = lv_conj(*a++);
++- }
+++ for (; number < num_points; number++) {
+++ *c++ = lv_conj(*a++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE3
++ #include <pmmintrin.h>
++
++-static inline void
++-volk_32fc_conjugate_32fc_a_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector, unsigned int num_points)
+++static inline void volk_32fc_conjugate_32fc_a_sse3(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int halfPoints = num_points / 2;
+++ unsigned int number = 0;
+++ const unsigned int halfPoints = num_points / 2;
++
++- __m128 x;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
+++ __m128 x;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
++
++- __m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);
+++ __m128 conjugator = _mm_setr_ps(0, -0.f, 0, -0.f);
++
++- for(;number < halfPoints; number++){
+++ for (; number < halfPoints; number++) {
++
++- x = _mm_load_ps((float*)a); // Load the complex data as ar,ai,br,bi
+++ x = _mm_load_ps((float*)a); // Load the complex data as ar,ai,br,bi
++
++- x = _mm_xor_ps(x, conjugator); // conjugate register
+++ x = _mm_xor_ps(x, conjugator); // conjugate register
++
++- _mm_store_ps((float*)c,x); // Store the results back into the C container
+++ _mm_store_ps((float*)c, x); // Store the results back into the C container
++
++- a += 2;
++- c += 2;
++- }
+++ a += 2;
+++ c += 2;
+++ }
++
++- if((num_points % 2) != 0) {
++- *c = lv_conj(*a);
++- }
+++ if ((num_points % 2) != 0) {
+++ *c = lv_conj(*a);
+++ }
++ }
++ #endif /* LV_HAVE_SSE3 */
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32fc_conjugate_32fc_a_neon(lv_32fc_t* cVector, const lv_32fc_t* aVector, unsigned int num_points)
+++static inline void volk_32fc_conjugate_32fc_a_neon(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ unsigned int num_points)
++ {
++- unsigned int number;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float32x4x2_t x;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
+++ float32x4x2_t x;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
++
++- for(number=0; number < quarterPoints; number++){
++- __VOLK_PREFETCH(a+4);
++- x = vld2q_f32((float*)a); // Load the complex data as ar,br,cr,dr; ai,bi,ci,di
+++ for (number = 0; number < quarterPoints; number++) {
+++ __VOLK_PREFETCH(a + 4);
+++ x = vld2q_f32((float*)a); // Load the complex data as ar,br,cr,dr; ai,bi,ci,di
++
++- // xor the imaginary lane
++- x.val[1] = vnegq_f32( x.val[1]);
+++ // xor the imaginary lane
+++ x.val[1] = vnegq_f32(x.val[1]);
++
++- vst2q_f32((float*)c,x); // Store the results back into the C container
+++ vst2q_f32((float*)c, x); // Store the results back into the C container
++
++- a += 4;
++- c += 4;
++- }
+++ a += 4;
+++ c += 4;
+++ }
++
++- for(number=quarterPoints*4; number < num_points; number++){
++- *c++ = lv_conj(*a++);
++- }
+++ for (number = quarterPoints * 4; number < num_points; number++) {
+++ *c++ = lv_conj(*a++);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_conjugate_32fc_a_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, unsigned int num_points)
+++static inline void volk_32fc_conjugate_32fc_a_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- unsigned int number = 0;
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = lv_conj(*aPtr++);
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = lv_conj(*aPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32fc_convert_16ic.h b/kernels/volk/volk_32fc_convert_16ic.h
++index 0ba2383..5788158 100644
++--- a/kernels/volk/volk_32fc_convert_16ic.h
+++++ b/kernels/volk/volk_32fc_convert_16ic.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_convert_16ic(lv_16sc_t* outputVector, const lv_32fc_t* inputVector, unsigned int num_points);
++- * \endcode
+++ * void volk_32fc_convert_16ic(lv_16sc_t* outputVector, const lv_32fc_t* inputVector,
+++ * unsigned int num_points); \endcode
++ *
++ * \b Inputs
++ * \li inputVector: The complex 32-bit float input data buffer.
++@@ -46,14 +46,16 @@
++ #ifndef INCLUDED_volk_32fc_convert_16ic_a_H
++ #define INCLUDED_volk_32fc_convert_16ic_a_H
++
+++#include "volk/volk_complex.h"
++ #include <limits.h>
++ #include <math.h>
++-#include "volk/volk_complex.h"
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void volk_32fc_convert_16ic_a_avx2(lv_16sc_t* outputVector, const lv_32fc_t* inputVector, unsigned int num_points)
+++static inline void volk_32fc_convert_16ic_a_avx2(lv_16sc_t* outputVector,
+++ const lv_32fc_t* inputVector,
+++ unsigned int num_points)
++ {
++ const unsigned int avx_iters = num_points / 8;
++
++@@ -71,44 +73,44 @@ static inline void volk_32fc_convert_16ic_a_avx2(lv_16sc_t* outputVector, const
++ const __m256 vmax_val = _mm256_set1_ps(max_val);
++ unsigned int i;
++
++- for(i = 0; i < avx_iters; i++)
++- {
++- inputVal1 = _mm256_load_ps((float*)inputVectorPtr);
++- inputVectorPtr += 8;
++- inputVal2 = _mm256_load_ps((float*)inputVectorPtr);
++- inputVectorPtr += 8;
++- __VOLK_PREFETCH(inputVectorPtr + 16);
++-
++- // Clip
++- ret1 = _mm256_max_ps(_mm256_min_ps(inputVal1, vmax_val), vmin_val);
++- ret2 = _mm256_max_ps(_mm256_min_ps(inputVal2, vmax_val), vmin_val);
++-
++- intInputVal1 = _mm256_cvtps_epi32(ret1);
++- intInputVal2 = _mm256_cvtps_epi32(ret2);
++-
++- intInputVal1 = _mm256_packs_epi32(intInputVal1, intInputVal2);
++- intInputVal1 = _mm256_permute4x64_epi64(intInputVal1, 0xd8);
++-
++- _mm256_store_si256((__m256i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 16;
++- }
++-
++- for(i = avx_iters * 16; i < num_points * 2; i++)
++- {
++- aux = *inputVectorPtr++;
++- if(aux > max_val)
++- aux = max_val;
++- else if(aux < min_val)
++- aux = min_val;
++- *outputVectorPtr++ = (int16_t)rintf(aux);
++- }
+++ for (i = 0; i < avx_iters; i++) {
+++ inputVal1 = _mm256_load_ps((float*)inputVectorPtr);
+++ inputVectorPtr += 8;
+++ inputVal2 = _mm256_load_ps((float*)inputVectorPtr);
+++ inputVectorPtr += 8;
+++ __VOLK_PREFETCH(inputVectorPtr + 16);
+++
+++ // Clip
+++ ret1 = _mm256_max_ps(_mm256_min_ps(inputVal1, vmax_val), vmin_val);
+++ ret2 = _mm256_max_ps(_mm256_min_ps(inputVal2, vmax_val), vmin_val);
+++
+++ intInputVal1 = _mm256_cvtps_epi32(ret1);
+++ intInputVal2 = _mm256_cvtps_epi32(ret2);
+++
+++ intInputVal1 = _mm256_packs_epi32(intInputVal1, intInputVal2);
+++ intInputVal1 = _mm256_permute4x64_epi64(intInputVal1, 0xd8);
+++
+++ _mm256_store_si256((__m256i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 16;
+++ }
+++
+++ for (i = avx_iters * 16; i < num_points * 2; i++) {
+++ aux = *inputVectorPtr++;
+++ if (aux > max_val)
+++ aux = max_val;
+++ else if (aux < min_val)
+++ aux = min_val;
+++ *outputVectorPtr++ = (int16_t)rintf(aux);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_32fc_convert_16ic_a_sse2(lv_16sc_t* outputVector, const lv_32fc_t* inputVector, unsigned int num_points)
+++static inline void volk_32fc_convert_16ic_a_sse2(lv_16sc_t* outputVector,
+++ const lv_32fc_t* inputVector,
+++ unsigned int num_points)
++ {
++ const unsigned int sse_iters = num_points / 4;
++
++@@ -126,34 +128,34 @@ static inline void volk_32fc_convert_16ic_a_sse2(lv_16sc_t* outputVector, const
++ const __m128 vmax_val = _mm_set_ps1(max_val);
++ unsigned int i;
++
++- for(i = 0; i < sse_iters; i++)
++- {
++- inputVal1 = _mm_load_ps((float*)inputVectorPtr); inputVectorPtr += 4;
++- inputVal2 = _mm_load_ps((float*)inputVectorPtr); inputVectorPtr += 4;
++- __VOLK_PREFETCH(inputVectorPtr + 8);
++-
++- // Clip
++- ret1 = _mm_max_ps(_mm_min_ps(inputVal1, vmax_val), vmin_val);
++- ret2 = _mm_max_ps(_mm_min_ps(inputVal2, vmax_val), vmin_val);
++-
++- intInputVal1 = _mm_cvtps_epi32(ret1);
++- intInputVal2 = _mm_cvtps_epi32(ret2);
++-
++- intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
++-
++- _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 8;
++- }
++-
++- for(i = sse_iters * 8; i < num_points * 2; i++)
++- {
++- aux = *inputVectorPtr++;
++- if(aux > max_val)
++- aux = max_val;
++- else if(aux < min_val)
++- aux = min_val;
++- *outputVectorPtr++ = (int16_t)rintf(aux);
++- }
+++ for (i = 0; i < sse_iters; i++) {
+++ inputVal1 = _mm_load_ps((float*)inputVectorPtr);
+++ inputVectorPtr += 4;
+++ inputVal2 = _mm_load_ps((float*)inputVectorPtr);
+++ inputVectorPtr += 4;
+++ __VOLK_PREFETCH(inputVectorPtr + 8);
+++
+++ // Clip
+++ ret1 = _mm_max_ps(_mm_min_ps(inputVal1, vmax_val), vmin_val);
+++ ret2 = _mm_max_ps(_mm_min_ps(inputVal2, vmax_val), vmin_val);
+++
+++ intInputVal1 = _mm_cvtps_epi32(ret1);
+++ intInputVal2 = _mm_cvtps_epi32(ret2);
+++
+++ intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
+++
+++ _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 8;
+++ }
+++
+++ for (i = sse_iters * 8; i < num_points * 2; i++) {
+++ aux = *inputVectorPtr++;
+++ if (aux > max_val)
+++ aux = max_val;
+++ else if (aux < min_val)
+++ aux = min_val;
+++ *outputVectorPtr++ = (int16_t)rintf(aux);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++@@ -161,13 +163,24 @@ static inline void volk_32fc_convert_16ic_a_sse2(lv_16sc_t* outputVector, const
++ #if LV_HAVE_NEONV7
++ #include <arm_neon.h>
++
++-#define VCVTRQ_S32_F32(res,val) \
++- __VOLK_ASM ("VCVTR.S32.F32 %[r0], %[v0]\n\t" : [r0]"=w"(res[0]) : [v0]"w"(val[0]) : ); \
++- __VOLK_ASM ("VCVTR.S32.F32 %[r1], %[v1]\n\t" : [r1]"=w"(res[1]) : [v1]"w"(val[1]) : ); \
++- __VOLK_ASM ("VCVTR.S32.F32 %[r2], %[v2]\n\t" : [r2]"=w"(res[2]) : [v2]"w"(val[2]) : ); \
++- __VOLK_ASM ("VCVTR.S32.F32 %[r3], %[v3]\n\t" : [r3]"=w"(res[3]) : [v3]"w"(val[3]) : );
++-
++-static inline void volk_32fc_convert_16ic_neon(lv_16sc_t* outputVector, const lv_32fc_t* inputVector, unsigned int num_points)
+++#define VCVTRQ_S32_F32(res, val) \
+++ __VOLK_ASM("VCVTR.S32.F32 %[r0], %[v0]\n\t" \
+++ : [r0] "=w"(res[0]) \
+++ : [v0] "w"(val[0]) \
+++ :); \
+++ __VOLK_ASM("VCVTR.S32.F32 %[r1], %[v1]\n\t" \
+++ : [r1] "=w"(res[1]) \
+++ : [v1] "w"(val[1]) \
+++ :); \
+++ __VOLK_ASM("VCVTR.S32.F32 %[r2], %[v2]\n\t" \
+++ : [r2] "=w"(res[2]) \
+++ : [v2] "w"(val[2]) \
+++ :); \
+++ __VOLK_ASM("VCVTR.S32.F32 %[r3], %[v3]\n\t" : [r3] "=w"(res[3]) : [v3] "w"(val[3]) :);
+++
+++static inline void volk_32fc_convert_16ic_neon(lv_16sc_t* outputVector,
+++ const lv_32fc_t* inputVector,
+++ unsigned int num_points)
++ {
++
++ const unsigned int neon_iters = num_points / 4;
++@@ -184,43 +197,41 @@ static inline void volk_32fc_convert_16ic_neon(lv_16sc_t* outputVector, const lv
++ const float32x4_t max_val = vmovq_n_f32(max_val_f);
++ float32x4_t ret1, ret2, a, b;
++
++- int32x4_t toint_a={0,0,0,0};
++- int32x4_t toint_b={0,0,0,0};
+++ int32x4_t toint_a = { 0, 0, 0, 0 };
+++ int32x4_t toint_b = { 0, 0, 0, 0 };
++ int16x4_t intInputVal1, intInputVal2;
++ int16x8_t res;
++
++- for(i = 0; i < neon_iters; i++)
++- {
++- a = vld1q_f32((const float32_t*)(inputVectorPtr));
++- inputVectorPtr += 4;
++- b = vld1q_f32((const float32_t*)(inputVectorPtr));
++- inputVectorPtr += 4;
++- __VOLK_PREFETCH(inputVectorPtr + 8);
++-
++- ret1 = vmaxq_f32(vminq_f32(a, max_val), min_val);
++- ret2 = vmaxq_f32(vminq_f32(b, max_val), min_val);
++-
++- // vcvtr takes into account the current rounding mode (as does rintf)
++- VCVTRQ_S32_F32(toint_a, ret1);
++- VCVTRQ_S32_F32(toint_b, ret2);
++-
++- intInputVal1 = vqmovn_s32(toint_a);
++- intInputVal2 = vqmovn_s32(toint_b);
++-
++- res = vcombine_s16(intInputVal1, intInputVal2);
++- vst1q_s16((int16_t*)outputVectorPtr, res);
++- outputVectorPtr += 8;
++- }
++-
++- for(i = neon_iters * 8; i < num_points * 2; i++)
++- {
++- aux = *inputVectorPtr++;
++- if(aux > max_val_f)
++- aux = max_val_f;
++- else if(aux < min_val_f)
++- aux = min_val_f;
++- *outputVectorPtr++ = (int16_t)rintf(aux);
++- }
+++ for (i = 0; i < neon_iters; i++) {
+++ a = vld1q_f32((const float32_t*)(inputVectorPtr));
+++ inputVectorPtr += 4;
+++ b = vld1q_f32((const float32_t*)(inputVectorPtr));
+++ inputVectorPtr += 4;
+++ __VOLK_PREFETCH(inputVectorPtr + 8);
+++
+++ ret1 = vmaxq_f32(vminq_f32(a, max_val), min_val);
+++ ret2 = vmaxq_f32(vminq_f32(b, max_val), min_val);
+++
+++ // vcvtr takes into account the current rounding mode (as does rintf)
+++ VCVTRQ_S32_F32(toint_a, ret1);
+++ VCVTRQ_S32_F32(toint_b, ret2);
+++
+++ intInputVal1 = vqmovn_s32(toint_a);
+++ intInputVal2 = vqmovn_s32(toint_b);
+++
+++ res = vcombine_s16(intInputVal1, intInputVal2);
+++ vst1q_s16((int16_t*)outputVectorPtr, res);
+++ outputVectorPtr += 8;
+++ }
+++
+++ for (i = neon_iters * 8; i < num_points * 2; i++) {
+++ aux = *inputVectorPtr++;
+++ if (aux > max_val_f)
+++ aux = max_val_f;
+++ else if (aux < min_val_f)
+++ aux = min_val_f;
+++ *outputVectorPtr++ = (int16_t)rintf(aux);
+++ }
++ }
++
++ #undef VCVTRQ_S32_F32
++@@ -229,7 +240,9 @@ static inline void volk_32fc_convert_16ic_neon(lv_16sc_t* outputVector, const lv
++ #if LV_HAVE_NEONV8
++ #include <arm_neon.h>
++
++-static inline void volk_32fc_convert_16ic_neonv8(lv_16sc_t* outputVector, const lv_32fc_t* inputVector, unsigned int num_points)
+++static inline void volk_32fc_convert_16ic_neonv8(lv_16sc_t* outputVector,
+++ const lv_32fc_t* inputVector,
+++ unsigned int num_points)
++ {
++ const unsigned int neon_iters = num_points / 4;
++
++@@ -245,50 +258,49 @@ static inline void volk_32fc_convert_16ic_neonv8(lv_16sc_t* outputVector, const
++ const float32x4_t max_val = vmovq_n_f32(max_val_f);
++ float32x4_t ret1, ret2, a, b;
++
++- int32x4_t toint_a={0,0,0,0}, toint_b={0,0,0,0};
+++ int32x4_t toint_a = { 0, 0, 0, 0 }, toint_b = { 0, 0, 0, 0 };
++ int16x4_t intInputVal1, intInputVal2;
++ int16x8_t res;
++
++- for(i = 0; i < neon_iters; i++)
++- {
++- a = vld1q_f32((const float32_t*)(inputVectorPtr));
++- inputVectorPtr += 4;
++- b = vld1q_f32((const float32_t*)(inputVectorPtr));
++- inputVectorPtr += 4;
++- __VOLK_PREFETCH(inputVectorPtr + 8);
++-
++- ret1 = vmaxq_f32(vminq_f32(a, max_val), min_val);
++- ret2 = vmaxq_f32(vminq_f32(b, max_val), min_val);
++-
++- // vrndiq takes into account the current rounding mode (as does rintf)
++- toint_a = vcvtq_s32_f32(vrndiq_f32(ret1));
++- toint_b = vcvtq_s32_f32(vrndiq_f32(ret2));
++-
++- intInputVal1 = vqmovn_s32(toint_a);
++- intInputVal2 = vqmovn_s32(toint_b);
++-
++- res = vcombine_s16(intInputVal1, intInputVal2);
++- vst1q_s16((int16_t*)outputVectorPtr, res);
++- outputVectorPtr += 8;
++- }
++-
++- for(i = neon_iters * 8; i < num_points * 2; i++)
++- {
++- aux = *inputVectorPtr++;
++- if(aux > max_val_f)
++- aux = max_val_f;
++- else if(aux < min_val_f)
++- aux = min_val_f;
++- *outputVectorPtr++ = (int16_t)rintf(aux);
++- }
+++ for (i = 0; i < neon_iters; i++) {
+++ a = vld1q_f32((const float32_t*)(inputVectorPtr));
+++ inputVectorPtr += 4;
+++ b = vld1q_f32((const float32_t*)(inputVectorPtr));
+++ inputVectorPtr += 4;
+++ __VOLK_PREFETCH(inputVectorPtr + 8);
+++
+++ ret1 = vmaxq_f32(vminq_f32(a, max_val), min_val);
+++ ret2 = vmaxq_f32(vminq_f32(b, max_val), min_val);
+++
+++ // vrndiq takes into account the current rounding mode (as does rintf)
+++ toint_a = vcvtq_s32_f32(vrndiq_f32(ret1));
+++ toint_b = vcvtq_s32_f32(vrndiq_f32(ret2));
+++
+++ intInputVal1 = vqmovn_s32(toint_a);
+++ intInputVal2 = vqmovn_s32(toint_b);
+++
+++ res = vcombine_s16(intInputVal1, intInputVal2);
+++ vst1q_s16((int16_t*)outputVectorPtr, res);
+++ outputVectorPtr += 8;
+++ }
+++
+++ for (i = neon_iters * 8; i < num_points * 2; i++) {
+++ aux = *inputVectorPtr++;
+++ if (aux > max_val_f)
+++ aux = max_val_f;
+++ else if (aux < min_val_f)
+++ aux = min_val_f;
+++ *outputVectorPtr++ = (int16_t)rintf(aux);
+++ }
++ }
++ #endif /* LV_HAVE_NEONV8 */
++
++
++-
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32fc_convert_16ic_generic(lv_16sc_t* outputVector, const lv_32fc_t* inputVector, unsigned int num_points)
+++static inline void volk_32fc_convert_16ic_generic(lv_16sc_t* outputVector,
+++ const lv_32fc_t* inputVector,
+++ unsigned int num_points)
++ {
++ float* inputVectorPtr = (float*)inputVector;
++ int16_t* outputVectorPtr = (int16_t*)outputVector;
++@@ -296,15 +308,14 @@ static inline void volk_32fc_convert_16ic_generic(lv_16sc_t* outputVector, const
++ const float max_val = (float)SHRT_MAX;
++ float aux;
++ unsigned int i;
++- for(i = 0; i < num_points * 2; i++)
++- {
++- aux = *inputVectorPtr++;
++- if(aux > max_val)
++- aux = max_val;
++- else if(aux < min_val)
++- aux = min_val;
++- *outputVectorPtr++ = (int16_t)rintf(aux);
++- }
+++ for (i = 0; i < num_points * 2; i++) {
+++ aux = *inputVectorPtr++;
+++ if (aux > max_val)
+++ aux = max_val;
+++ else if (aux < min_val)
+++ aux = min_val;
+++ *outputVectorPtr++ = (int16_t)rintf(aux);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -313,15 +324,17 @@ static inline void volk_32fc_convert_16ic_generic(lv_16sc_t* outputVector, const
++ #ifndef INCLUDED_volk_32fc_convert_16ic_u_H
++ #define INCLUDED_volk_32fc_convert_16ic_u_H
++
+++#include "volk/volk_complex.h"
++ #include <limits.h>
++ #include <math.h>
++-#include "volk/volk_complex.h"
++
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void volk_32fc_convert_16ic_u_avx2(lv_16sc_t* outputVector, const lv_32fc_t* inputVector, unsigned int num_points)
+++static inline void volk_32fc_convert_16ic_u_avx2(lv_16sc_t* outputVector,
+++ const lv_32fc_t* inputVector,
+++ unsigned int num_points)
++ {
++ const unsigned int avx_iters = num_points / 8;
++
++@@ -339,37 +352,35 @@ static inline void volk_32fc_convert_16ic_u_avx2(lv_16sc_t* outputVector, const
++ const __m256 vmax_val = _mm256_set1_ps(max_val);
++ unsigned int i;
++
++- for(i = 0; i < avx_iters; i++)
++- {
++- inputVal1 = _mm256_loadu_ps((float*)inputVectorPtr);
++- inputVectorPtr += 8;
++- inputVal2 = _mm256_loadu_ps((float*)inputVectorPtr);
++- inputVectorPtr += 8;
++- __VOLK_PREFETCH(inputVectorPtr + 16);
++-
++- // Clip
++- ret1 = _mm256_max_ps(_mm256_min_ps(inputVal1, vmax_val), vmin_val);
++- ret2 = _mm256_max_ps(_mm256_min_ps(inputVal2, vmax_val), vmin_val);
++-
++- intInputVal1 = _mm256_cvtps_epi32(ret1);
++- intInputVal2 = _mm256_cvtps_epi32(ret2);
++-
++- intInputVal1 = _mm256_packs_epi32(intInputVal1, intInputVal2);
++- intInputVal1 = _mm256_permute4x64_epi64(intInputVal1, 0xd8);
++-
++- _mm256_storeu_si256((__m256i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 16;
++- }
++-
++- for(i = avx_iters * 16; i < num_points * 2; i++)
++- {
++- aux = *inputVectorPtr++;
++- if(aux > max_val)
++- aux = max_val;
++- else if(aux < min_val)
++- aux = min_val;
++- *outputVectorPtr++ = (int16_t)rintf(aux);
++- }
+++ for (i = 0; i < avx_iters; i++) {
+++ inputVal1 = _mm256_loadu_ps((float*)inputVectorPtr);
+++ inputVectorPtr += 8;
+++ inputVal2 = _mm256_loadu_ps((float*)inputVectorPtr);
+++ inputVectorPtr += 8;
+++ __VOLK_PREFETCH(inputVectorPtr + 16);
+++
+++ // Clip
+++ ret1 = _mm256_max_ps(_mm256_min_ps(inputVal1, vmax_val), vmin_val);
+++ ret2 = _mm256_max_ps(_mm256_min_ps(inputVal2, vmax_val), vmin_val);
+++
+++ intInputVal1 = _mm256_cvtps_epi32(ret1);
+++ intInputVal2 = _mm256_cvtps_epi32(ret2);
+++
+++ intInputVal1 = _mm256_packs_epi32(intInputVal1, intInputVal2);
+++ intInputVal1 = _mm256_permute4x64_epi64(intInputVal1, 0xd8);
+++
+++ _mm256_storeu_si256((__m256i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 16;
+++ }
+++
+++ for (i = avx_iters * 16; i < num_points * 2; i++) {
+++ aux = *inputVectorPtr++;
+++ if (aux > max_val)
+++ aux = max_val;
+++ else if (aux < min_val)
+++ aux = min_val;
+++ *outputVectorPtr++ = (int16_t)rintf(aux);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -377,7 +388,9 @@ static inline void volk_32fc_convert_16ic_u_avx2(lv_16sc_t* outputVector, const
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_32fc_convert_16ic_u_sse2(lv_16sc_t* outputVector, const lv_32fc_t* inputVector, unsigned int num_points)
+++static inline void volk_32fc_convert_16ic_u_sse2(lv_16sc_t* outputVector,
+++ const lv_32fc_t* inputVector,
+++ unsigned int num_points)
++ {
++ const unsigned int sse_iters = num_points / 4;
++
++@@ -395,36 +408,34 @@ static inline void volk_32fc_convert_16ic_u_sse2(lv_16sc_t* outputVector, const
++ const __m128 vmax_val = _mm_set_ps1(max_val);
++
++ unsigned int i;
++- for(i = 0; i < sse_iters; i++)
++- {
++- inputVal1 = _mm_loadu_ps((float*)inputVectorPtr);
++- inputVectorPtr += 4;
++- inputVal2 = _mm_loadu_ps((float*)inputVectorPtr);
++- inputVectorPtr += 4;
++- __VOLK_PREFETCH(inputVectorPtr + 8);
++-
++- // Clip
++- ret1 = _mm_max_ps(_mm_min_ps(inputVal1, vmax_val), vmin_val);
++- ret2 = _mm_max_ps(_mm_min_ps(inputVal2, vmax_val), vmin_val);
++-
++- intInputVal1 = _mm_cvtps_epi32(ret1);
++- intInputVal2 = _mm_cvtps_epi32(ret2);
++-
++- intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
++-
++- _mm_storeu_si128((__m128i*)outputVectorPtr, intInputVal1);
++- outputVectorPtr += 8;
++- }
++-
++- for(i = sse_iters * 8; i < num_points * 2; i++)
++- {
++- aux = *inputVectorPtr++;
++- if(aux > max_val)
++- aux = max_val;
++- else if(aux < min_val)
++- aux = min_val;
++- *outputVectorPtr++ = (int16_t)rintf(aux);
++- }
+++ for (i = 0; i < sse_iters; i++) {
+++ inputVal1 = _mm_loadu_ps((float*)inputVectorPtr);
+++ inputVectorPtr += 4;
+++ inputVal2 = _mm_loadu_ps((float*)inputVectorPtr);
+++ inputVectorPtr += 4;
+++ __VOLK_PREFETCH(inputVectorPtr + 8);
+++
+++ // Clip
+++ ret1 = _mm_max_ps(_mm_min_ps(inputVal1, vmax_val), vmin_val);
+++ ret2 = _mm_max_ps(_mm_min_ps(inputVal2, vmax_val), vmin_val);
+++
+++ intInputVal1 = _mm_cvtps_epi32(ret1);
+++ intInputVal2 = _mm_cvtps_epi32(ret2);
+++
+++ intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
+++
+++ _mm_storeu_si128((__m128i*)outputVectorPtr, intInputVal1);
+++ outputVectorPtr += 8;
+++ }
+++
+++ for (i = sse_iters * 8; i < num_points * 2; i++) {
+++ aux = *inputVectorPtr++;
+++ if (aux > max_val)
+++ aux = max_val;
+++ else if (aux < min_val)
+++ aux = min_val;
+++ *outputVectorPtr++ = (int16_t)rintf(aux);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++ #endif /* INCLUDED_volk_32fc_convert_16ic_u_H */
++diff --git a/kernels/volk/volk_32fc_deinterleave_32f_x2.h b/kernels/volk/volk_32fc_deinterleave_32f_x2.h
++index 40cd664..1a06c48 100644
++--- a/kernels/volk/volk_32fc_deinterleave_32f_x2.h
+++++ b/kernels/volk/volk_32fc_deinterleave_32f_x2.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_deinterleave_32f_x2(float* iBuffer, float* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_deinterleave_32f_x2(float* iBuffer, float* qBuffer, const lv_32fc_t*
+++ * complexVector, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -78,86 +78,88 @@
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++-static inline void
++-volk_32fc_deinterleave_32f_x2_a_avx(float* iBuffer, float* qBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_32f_x2_a_avx(float* iBuffer,
+++ float* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- const float* complexVectorPtr = (float*)complexVector;
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
++-
++- unsigned int number = 0;
++- // Mask for real and imaginary parts
++- const unsigned int eighthPoints = num_points / 8;
++- __m256 cplxValue1, cplxValue2, complex1, complex2, iValue, qValue;
++- for(;number < eighthPoints; number++){
++- cplxValue1 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- cplxValue2 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- complex1 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
++- complex2 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
++-
++- // Arrange in i1i2i3i4 format
++- iValue = _mm256_shuffle_ps(complex1, complex2, 0x88);
++- // Arrange in q1q2q3q4 format
++- qValue = _mm256_shuffle_ps(complex1, complex2, 0xdd);
++-
++- _mm256_store_ps(iBufferPtr, iValue);
++- _mm256_store_ps(qBufferPtr, qValue);
++-
++- iBufferPtr += 8;
++- qBufferPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
+++
+++ unsigned int number = 0;
+++ // Mask for real and imaginary parts
+++ const unsigned int eighthPoints = num_points / 8;
+++ __m256 cplxValue1, cplxValue2, complex1, complex2, iValue, qValue;
+++ for (; number < eighthPoints; number++) {
+++ cplxValue1 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ cplxValue2 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ complex1 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
+++ complex2 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
+++
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm256_shuffle_ps(complex1, complex2, 0x88);
+++ // Arrange in q1q2q3q4 format
+++ qValue = _mm256_shuffle_ps(complex1, complex2, 0xdd);
+++
+++ _mm256_store_ps(iBufferPtr, iValue);
+++ _mm256_store_ps(qBufferPtr, qValue);
+++
+++ iBufferPtr += 8;
+++ qBufferPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32fc_deinterleave_32f_x2_a_sse(float* iBuffer, float* qBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_32f_x2_a_sse(float* iBuffer,
+++ float* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- const float* complexVectorPtr = (float*)complexVector;
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
++-
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++- __m128 cplxValue1, cplxValue2, iValue, qValue;
++- for(;number < quarterPoints; number++){
++- cplxValue1 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- cplxValue2 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- // Arrange in i1i2i3i4 format
++- iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
++- // Arrange in q1q2q3q4 format
++- qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));
++-
++- _mm_store_ps(iBufferPtr, iValue);
++- _mm_store_ps(qBufferPtr, qValue);
++-
++- iBufferPtr += 4;
++- qBufferPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
+++
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++ __m128 cplxValue1, cplxValue2, iValue, qValue;
+++ for (; number < quarterPoints; number++) {
+++ cplxValue1 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ cplxValue2 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
+++ // Arrange in q1q2q3q4 format
+++ qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3, 1, 3, 1));
+++
+++ _mm_store_ps(iBufferPtr, iValue);
+++ _mm_store_ps(qBufferPtr, qValue);
+++
+++ iBufferPtr += 4;
+++ qBufferPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -165,48 +167,50 @@ volk_32fc_deinterleave_32f_x2_a_sse(float* iBuffer, float* qBuffer, const lv_32f
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32fc_deinterleave_32f_x2_neon(float* iBuffer, float* qBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_32f_x2_neon(float* iBuffer,
+++ float* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- unsigned int quarter_points = num_points / 4;
++- const float* complexVectorPtr = (float*)complexVector;
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
++- float32x4x2_t complexInput;
++-
++- for(number = 0; number < quarter_points; number++){
++- complexInput = vld2q_f32(complexVectorPtr);
++- vst1q_f32( iBufferPtr, complexInput.val[0] );
++- vst1q_f32( qBufferPtr, complexInput.val[1] );
++- complexVectorPtr += 8;
++- iBufferPtr += 4;
++- qBufferPtr += 4;
++- }
++-
++- for(number = quarter_points*4; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ unsigned int quarter_points = num_points / 4;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
+++ float32x4x2_t complexInput;
+++
+++ for (number = 0; number < quarter_points; number++) {
+++ complexInput = vld2q_f32(complexVectorPtr);
+++ vst1q_f32(iBufferPtr, complexInput.val[0]);
+++ vst1q_f32(qBufferPtr, complexInput.val[1]);
+++ complexVectorPtr += 8;
+++ iBufferPtr += 4;
+++ qBufferPtr += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_deinterleave_32f_x2_generic(float* iBuffer, float* qBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_32f_x2_generic(float* iBuffer,
+++ float* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- const float* complexVectorPtr = (float*)complexVector;
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
++- unsigned int number;
++- for(number = 0; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
+++ unsigned int number;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -221,45 +225,46 @@ volk_32fc_deinterleave_32f_x2_generic(float* iBuffer, float* qBuffer, const lv_3
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++-static inline void
++-volk_32fc_deinterleave_32f_x2_u_avx(float* iBuffer, float* qBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_32f_x2_u_avx(float* iBuffer,
+++ float* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- const float* complexVectorPtr = (float*)complexVector;
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
++-
++- unsigned int number = 0;
++- // Mask for real and imaginary parts
++- const unsigned int eighthPoints = num_points / 8;
++- __m256 cplxValue1, cplxValue2, complex1, complex2, iValue, qValue;
++- for(;number < eighthPoints; number++){
++- cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- cplxValue2 = _mm256_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- complex1 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
++- complex2 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
++-
++- // Arrange in i1i2i3i4 format
++- iValue = _mm256_shuffle_ps(complex1, complex2, 0x88);
++- // Arrange in q1q2q3q4 format
++- qValue = _mm256_shuffle_ps(complex1, complex2, 0xdd);
++-
++- _mm256_storeu_ps(iBufferPtr, iValue);
++- _mm256_storeu_ps(qBufferPtr, qValue);
++-
++- iBufferPtr += 8;
++- qBufferPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
+++
+++ unsigned int number = 0;
+++ // Mask for real and imaginary parts
+++ const unsigned int eighthPoints = num_points / 8;
+++ __m256 cplxValue1, cplxValue2, complex1, complex2, iValue, qValue;
+++ for (; number < eighthPoints; number++) {
+++ cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ cplxValue2 = _mm256_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ complex1 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
+++ complex2 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
+++
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm256_shuffle_ps(complex1, complex2, 0x88);
+++ // Arrange in q1q2q3q4 format
+++ qValue = _mm256_shuffle_ps(complex1, complex2, 0xdd);
+++
+++ _mm256_storeu_ps(iBufferPtr, iValue);
+++ _mm256_storeu_ps(qBufferPtr, qValue);
+++
+++ iBufferPtr += 8;
+++ qBufferPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++ #endif /* INCLUDED_volk_32fc_deinterleave_32f_x2_u_H */
++diff --git a/kernels/volk/volk_32fc_deinterleave_64f_x2.h b/kernels/volk/volk_32fc_deinterleave_64f_x2.h
++index 3e799cb..3b69c3c 100644
++--- a/kernels/volk/volk_32fc_deinterleave_64f_x2.h
+++++ b/kernels/volk/volk_32fc_deinterleave_64f_x2.h
++@@ -79,110 +79,113 @@
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_deinterleave_64f_x2_u_avx(double *iBuffer, double *qBuffer,
++- const lv_32fc_t *complexVector,
++- unsigned int num_points) {
++- unsigned int number = 0;
++-
++- const float *complexVectorPtr = (float *)complexVector;
++- double *iBufferPtr = iBuffer;
++- double *qBufferPtr = qBuffer;
++-
++- const unsigned int quarterPoints = num_points / 4;
++- __m256 cplxValue;
++- __m128 complexH, complexL, fVal;
++- __m256d dVal;
++-
++- for (; number < quarterPoints; number++) {
++-
++- cplxValue = _mm256_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- complexH = _mm256_extractf128_ps(cplxValue, 1);
++- complexL = _mm256_extractf128_ps(cplxValue, 0);
++-
++- // Arrange in i1i2i1i2 format
++- fVal = _mm_shuffle_ps(complexL, complexH, _MM_SHUFFLE(2, 0, 2, 0));
++- dVal = _mm256_cvtps_pd(fVal);
++- _mm256_storeu_pd(iBufferPtr, dVal);
++-
++- // Arrange in q1q2q1q2 format
++- fVal = _mm_shuffle_ps(complexL, complexH, _MM_SHUFFLE(3, 1, 3, 1));
++- dVal = _mm256_cvtps_pd(fVal);
++- _mm256_storeu_pd(qBufferPtr, dVal);
++-
++- iBufferPtr += 4;
++- qBufferPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for (; number < num_points; number++) {
++- *iBufferPtr++ = *complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++static inline void volk_32fc_deinterleave_64f_x2_u_avx(double* iBuffer,
+++ double* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ double* iBufferPtr = iBuffer;
+++ double* qBufferPtr = qBuffer;
+++
+++ const unsigned int quarterPoints = num_points / 4;
+++ __m256 cplxValue;
+++ __m128 complexH, complexL, fVal;
+++ __m256d dVal;
+++
+++ for (; number < quarterPoints; number++) {
+++
+++ cplxValue = _mm256_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ complexH = _mm256_extractf128_ps(cplxValue, 1);
+++ complexL = _mm256_extractf128_ps(cplxValue, 0);
+++
+++ // Arrange in i1i2i1i2 format
+++ fVal = _mm_shuffle_ps(complexL, complexH, _MM_SHUFFLE(2, 0, 2, 0));
+++ dVal = _mm256_cvtps_pd(fVal);
+++ _mm256_storeu_pd(iBufferPtr, dVal);
+++
+++ // Arrange in q1q2q1q2 format
+++ fVal = _mm_shuffle_ps(complexL, complexH, _MM_SHUFFLE(3, 1, 3, 1));
+++ dVal = _mm256_cvtps_pd(fVal);
+++ _mm256_storeu_pd(qBufferPtr, dVal);
+++
+++ iBufferPtr += 4;
+++ qBufferPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32fc_deinterleave_64f_x2_u_sse2(double *iBuffer, double *qBuffer,
++- const lv_32fc_t *complexVector,
++- unsigned int num_points) {
++- unsigned int number = 0;
++-
++- const float *complexVectorPtr = (float *)complexVector;
++- double *iBufferPtr = iBuffer;
++- double *qBufferPtr = qBuffer;
++-
++- const unsigned int halfPoints = num_points / 2;
++- __m128 cplxValue, fVal;
++- __m128d dVal;
++-
++- for (; number < halfPoints; number++) {
++-
++- cplxValue = _mm_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- // Arrange in i1i2i1i2 format
++- fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(2, 0, 2, 0));
++- dVal = _mm_cvtps_pd(fVal);
++- _mm_storeu_pd(iBufferPtr, dVal);
++-
++- // Arrange in q1q2q1q2 format
++- fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(3, 1, 3, 1));
++- dVal = _mm_cvtps_pd(fVal);
++- _mm_storeu_pd(qBufferPtr, dVal);
++-
++- iBufferPtr += 2;
++- qBufferPtr += 2;
++- }
++-
++- number = halfPoints * 2;
++- for (; number < num_points; number++) {
++- *iBufferPtr++ = *complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++static inline void volk_32fc_deinterleave_64f_x2_u_sse2(double* iBuffer,
+++ double* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ double* iBufferPtr = iBuffer;
+++ double* qBufferPtr = qBuffer;
+++
+++ const unsigned int halfPoints = num_points / 2;
+++ __m128 cplxValue, fVal;
+++ __m128d dVal;
+++
+++ for (; number < halfPoints; number++) {
+++
+++ cplxValue = _mm_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ // Arrange in i1i2i1i2 format
+++ fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(2, 0, 2, 0));
+++ dVal = _mm_cvtps_pd(fVal);
+++ _mm_storeu_pd(iBufferPtr, dVal);
+++
+++ // Arrange in q1q2q1q2 format
+++ fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(3, 1, 3, 1));
+++ dVal = _mm_cvtps_pd(fVal);
+++ _mm_storeu_pd(qBufferPtr, dVal);
+++
+++ iBufferPtr += 2;
+++ qBufferPtr += 2;
+++ }
+++
+++ number = halfPoints * 2;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_deinterleave_64f_x2_generic(double *iBuffer, double *qBuffer,
++- const lv_32fc_t *complexVector,
++- unsigned int num_points) {
++- unsigned int number = 0;
++- const float *complexVectorPtr = (float *)complexVector;
++- double *iBufferPtr = iBuffer;
++- double *qBufferPtr = qBuffer;
++-
++- for (number = 0; number < num_points; number++) {
++- *iBufferPtr++ = (double)*complexVectorPtr++;
++- *qBufferPtr++ = (double)*complexVectorPtr++;
++- }
+++static inline void volk_32fc_deinterleave_64f_x2_generic(double* iBuffer,
+++ double* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ double* iBufferPtr = iBuffer;
+++ double* qBufferPtr = qBuffer;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = (double)*complexVectorPtr++;
+++ *qBufferPtr++ = (double)*complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -196,146 +199,150 @@ volk_32fc_deinterleave_64f_x2_generic(double *iBuffer, double *qBuffer,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_deinterleave_64f_x2_a_avx(double *iBuffer, double *qBuffer,
++- const lv_32fc_t *complexVector,
++- unsigned int num_points) {
++- unsigned int number = 0;
++-
++- const float *complexVectorPtr = (float *)complexVector;
++- double *iBufferPtr = iBuffer;
++- double *qBufferPtr = qBuffer;
++-
++- const unsigned int quarterPoints = num_points / 4;
++- __m256 cplxValue;
++- __m128 complexH, complexL, fVal;
++- __m256d dVal;
++-
++- for (; number < quarterPoints; number++) {
++-
++- cplxValue = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- complexH = _mm256_extractf128_ps(cplxValue, 1);
++- complexL = _mm256_extractf128_ps(cplxValue, 0);
++-
++- // Arrange in i1i2i1i2 format
++- fVal = _mm_shuffle_ps(complexL, complexH, _MM_SHUFFLE(2, 0, 2, 0));
++- dVal = _mm256_cvtps_pd(fVal);
++- _mm256_store_pd(iBufferPtr, dVal);
++-
++- // Arrange in q1q2q1q2 format
++- fVal = _mm_shuffle_ps(complexL, complexH, _MM_SHUFFLE(3, 1, 3, 1));
++- dVal = _mm256_cvtps_pd(fVal);
++- _mm256_store_pd(qBufferPtr, dVal);
++-
++- iBufferPtr += 4;
++- qBufferPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for (; number < num_points; number++) {
++- *iBufferPtr++ = *complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++static inline void volk_32fc_deinterleave_64f_x2_a_avx(double* iBuffer,
+++ double* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ double* iBufferPtr = iBuffer;
+++ double* qBufferPtr = qBuffer;
+++
+++ const unsigned int quarterPoints = num_points / 4;
+++ __m256 cplxValue;
+++ __m128 complexH, complexL, fVal;
+++ __m256d dVal;
+++
+++ for (; number < quarterPoints; number++) {
+++
+++ cplxValue = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ complexH = _mm256_extractf128_ps(cplxValue, 1);
+++ complexL = _mm256_extractf128_ps(cplxValue, 0);
+++
+++ // Arrange in i1i2i1i2 format
+++ fVal = _mm_shuffle_ps(complexL, complexH, _MM_SHUFFLE(2, 0, 2, 0));
+++ dVal = _mm256_cvtps_pd(fVal);
+++ _mm256_store_pd(iBufferPtr, dVal);
+++
+++ // Arrange in q1q2q1q2 format
+++ fVal = _mm_shuffle_ps(complexL, complexH, _MM_SHUFFLE(3, 1, 3, 1));
+++ dVal = _mm256_cvtps_pd(fVal);
+++ _mm256_store_pd(qBufferPtr, dVal);
+++
+++ iBufferPtr += 4;
+++ qBufferPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32fc_deinterleave_64f_x2_a_sse2(double *iBuffer, double *qBuffer,
++- const lv_32fc_t *complexVector,
++- unsigned int num_points) {
++- unsigned int number = 0;
++-
++- const float *complexVectorPtr = (float *)complexVector;
++- double *iBufferPtr = iBuffer;
++- double *qBufferPtr = qBuffer;
++-
++- const unsigned int halfPoints = num_points / 2;
++- __m128 cplxValue, fVal;
++- __m128d dVal;
++-
++- for (; number < halfPoints; number++) {
++-
++- cplxValue = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- // Arrange in i1i2i1i2 format
++- fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(2, 0, 2, 0));
++- dVal = _mm_cvtps_pd(fVal);
++- _mm_store_pd(iBufferPtr, dVal);
++-
++- // Arrange in q1q2q1q2 format
++- fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(3, 1, 3, 1));
++- dVal = _mm_cvtps_pd(fVal);
++- _mm_store_pd(qBufferPtr, dVal);
++-
++- iBufferPtr += 2;
++- qBufferPtr += 2;
++- }
++-
++- number = halfPoints * 2;
++- for (; number < num_points; number++) {
++- *iBufferPtr++ = *complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++static inline void volk_32fc_deinterleave_64f_x2_a_sse2(double* iBuffer,
+++ double* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ double* iBufferPtr = iBuffer;
+++ double* qBufferPtr = qBuffer;
+++
+++ const unsigned int halfPoints = num_points / 2;
+++ __m128 cplxValue, fVal;
+++ __m128d dVal;
+++
+++ for (; number < halfPoints; number++) {
+++
+++ cplxValue = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ // Arrange in i1i2i1i2 format
+++ fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(2, 0, 2, 0));
+++ dVal = _mm_cvtps_pd(fVal);
+++ _mm_store_pd(iBufferPtr, dVal);
+++
+++ // Arrange in q1q2q1q2 format
+++ fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(3, 1, 3, 1));
+++ dVal = _mm_cvtps_pd(fVal);
+++ _mm_store_pd(qBufferPtr, dVal);
+++
+++ iBufferPtr += 2;
+++ qBufferPtr += 2;
+++ }
+++
+++ number = halfPoints * 2;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_deinterleave_64f_x2_a_generic(double *iBuffer, double *qBuffer,
++- const lv_32fc_t *complexVector,
++- unsigned int num_points) {
++- unsigned int number = 0;
++- const float *complexVectorPtr = (float *)complexVector;
++- double *iBufferPtr = iBuffer;
++- double *qBufferPtr = qBuffer;
++-
++- for (number = 0; number < num_points; number++) {
++- *iBufferPtr++ = (double)*complexVectorPtr++;
++- *qBufferPtr++ = (double)*complexVectorPtr++;
++- }
+++static inline void volk_32fc_deinterleave_64f_x2_a_generic(double* iBuffer,
+++ double* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ double* iBufferPtr = iBuffer;
+++ double* qBufferPtr = qBuffer;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = (double)*complexVectorPtr++;
+++ *qBufferPtr++ = (double)*complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_NEONV8
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32fc_deinterleave_64f_x2_neon(double *iBuffer, double *qBuffer,
++- const lv_32fc_t *complexVector,
++- unsigned int num_points) {
++- unsigned int number = 0;
++- unsigned int half_points = num_points / 2;
++- const float *complexVectorPtr = (float *)complexVector;
++- double *iBufferPtr = iBuffer;
++- double *qBufferPtr = qBuffer;
++- float32x2x2_t complexInput;
++- float64x2_t iVal, qVal;
++-
++- for (number = 0; number < half_points; number++) {
++- complexInput = vld2_f32(complexVectorPtr);
++-
++- iVal = vcvt_f64_f32(complexInput.val[0]);
++- qVal = vcvt_f64_f32(complexInput.val[1]);
++-
++- vst1q_f64(iBufferPtr, iVal);
++- vst1q_f64(qBufferPtr, qVal);
++-
++- complexVectorPtr += 4;
++- iBufferPtr += 2;
++- qBufferPtr += 2;
++- }
++-
++- for (number = half_points * 2; number < num_points; number++) {
++- *iBufferPtr++ = (double)*complexVectorPtr++;
++- *qBufferPtr++ = (double)*complexVectorPtr++;
++- }
+++static inline void volk_32fc_deinterleave_64f_x2_neon(double* iBuffer,
+++ double* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ unsigned int half_points = num_points / 2;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ double* iBufferPtr = iBuffer;
+++ double* qBufferPtr = qBuffer;
+++ float32x2x2_t complexInput;
+++ float64x2_t iVal, qVal;
+++
+++ for (number = 0; number < half_points; number++) {
+++ complexInput = vld2_f32(complexVectorPtr);
+++
+++ iVal = vcvt_f64_f32(complexInput.val[0]);
+++ qVal = vcvt_f64_f32(complexInput.val[1]);
+++
+++ vst1q_f64(iBufferPtr, iVal);
+++ vst1q_f64(qBufferPtr, qVal);
+++
+++ complexVectorPtr += 4;
+++ iBufferPtr += 2;
+++ qBufferPtr += 2;
+++ }
+++
+++ for (number = half_points * 2; number < num_points; number++) {
+++ *iBufferPtr++ = (double)*complexVectorPtr++;
+++ *qBufferPtr++ = (double)*complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_NEONV8 */
++
++diff --git a/kernels/volk/volk_32fc_deinterleave_imag_32f.h b/kernels/volk/volk_32fc_deinterleave_imag_32f.h
++index 13f9764..e3dfa12 100644
++--- a/kernels/volk/volk_32fc_deinterleave_imag_32f.h
+++++ b/kernels/volk/volk_32fc_deinterleave_imag_32f.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_deinterleave_image_32f(float* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_deinterleave_image_32f(float* qBuffer, const lv_32fc_t* complexVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -76,121 +76,121 @@
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_deinterleave_imag_32f_a_avx(float* qBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_imag_32f_a_avx(float* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++- const float* complexVectorPtr = (const float*)complexVector;
++- float* qBufferPtr = qBuffer;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++ const float* complexVectorPtr = (const float*)complexVector;
+++ float* qBufferPtr = qBuffer;
++
++- __m256 cplxValue1, cplxValue2, complex1, complex2, qValue;
++- for(;number < eighthPoints; number++){
+++ __m256 cplxValue1, cplxValue2, complex1, complex2, qValue;
+++ for (; number < eighthPoints; number++) {
++
++- cplxValue1 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ cplxValue1 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- cplxValue2 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ cplxValue2 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- complex1 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
++- complex2 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
+++ complex1 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
+++ complex2 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
++
++- // Arrange in q1q2q3q4 format
++- qValue = _mm256_shuffle_ps(complex1, complex2, 0xdd);
+++ // Arrange in q1q2q3q4 format
+++ qValue = _mm256_shuffle_ps(complex1, complex2, 0xdd);
++
++- _mm256_store_ps(qBufferPtr, qValue);
+++ _mm256_store_ps(qBufferPtr, qValue);
++
++- qBufferPtr += 8;
++- }
+++ qBufferPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32fc_deinterleave_imag_32f_a_sse(float* qBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_imag_32f_a_sse(float* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* complexVectorPtr = (const float*)complexVector;
++- float* qBufferPtr = qBuffer;
+++ const float* complexVectorPtr = (const float*)complexVector;
+++ float* qBufferPtr = qBuffer;
++
++- __m128 cplxValue1, cplxValue2, iValue;
++- for(;number < quarterPoints; number++){
+++ __m128 cplxValue1, cplxValue2, iValue;
+++ for (; number < quarterPoints; number++) {
++
++- cplxValue1 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ cplxValue1 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- cplxValue2 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ cplxValue2 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- // Arrange in q1q2q3q4 format
++- iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));
+++ // Arrange in q1q2q3q4 format
+++ iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3, 1, 3, 1));
++
++- _mm_store_ps(qBufferPtr, iValue);
+++ _mm_store_ps(qBufferPtr, iValue);
++
++- qBufferPtr += 4;
++- }
+++ qBufferPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32fc_deinterleave_imag_32f_neon(float* qBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_imag_32f_neon(float* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- unsigned int quarter_points = num_points / 4;
++- const float* complexVectorPtr = (float*)complexVector;
++- float* qBufferPtr = qBuffer;
++- float32x4x2_t complexInput;
++-
++- for(number = 0; number < quarter_points; number++){
++- complexInput = vld2q_f32(complexVectorPtr);
++- vst1q_f32( qBufferPtr, complexInput.val[1] );
++- complexVectorPtr += 8;
++- qBufferPtr += 4;
++- }
++-
++- for(number = quarter_points*4; number < num_points; number++){
++- complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ unsigned int quarter_points = num_points / 4;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* qBufferPtr = qBuffer;
+++ float32x4x2_t complexInput;
+++
+++ for (number = 0; number < quarter_points; number++) {
+++ complexInput = vld2q_f32(complexVectorPtr);
+++ vst1q_f32(qBufferPtr, complexInput.val[1]);
+++ complexVectorPtr += 8;
+++ qBufferPtr += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_deinterleave_imag_32f_generic(float* qBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_imag_32f_generic(float* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const float* complexVectorPtr = (float*)complexVector;
++- float* qBufferPtr = qBuffer;
++- for(number = 0; number < num_points; number++){
++- complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* qBufferPtr = qBuffer;
+++ for (number = 0; number < num_points; number++) {
+++ complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -206,40 +206,40 @@ volk_32fc_deinterleave_imag_32f_generic(float* qBuffer, const lv_32fc_t* complex
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_deinterleave_imag_32f_u_avx(float* qBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_imag_32f_u_avx(float* qBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++- const float* complexVectorPtr = (const float*)complexVector;
++- float* qBufferPtr = qBuffer;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++ const float* complexVectorPtr = (const float*)complexVector;
+++ float* qBufferPtr = qBuffer;
++
++- __m256 cplxValue1, cplxValue2, complex1, complex2, qValue;
++- for(;number < eighthPoints; number++){
+++ __m256 cplxValue1, cplxValue2, complex1, complex2, qValue;
+++ for (; number < eighthPoints; number++) {
++
++- cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- cplxValue2 = _mm256_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ cplxValue2 = _mm256_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- complex1 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
++- complex2 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
+++ complex1 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x20);
+++ complex2 = _mm256_permute2f128_ps(cplxValue1, cplxValue2, 0x31);
++
++- // Arrange in q1q2q3q4 format
++- qValue = _mm256_shuffle_ps(complex1, complex2, 0xdd);
+++ // Arrange in q1q2q3q4 format
+++ qValue = _mm256_shuffle_ps(complex1, complex2, 0xdd);
++
++- _mm256_storeu_ps(qBufferPtr, qValue);
+++ _mm256_storeu_ps(qBufferPtr, qValue);
++
++- qBufferPtr += 8;
++- }
+++ qBufferPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- complexVectorPtr++;
++- *qBufferPtr++ = *complexVectorPtr++;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ complexVectorPtr++;
+++ *qBufferPtr++ = *complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++ #endif /* INCLUDED_volk_32fc_deinterleave_imag_32f_u_H */
++diff --git a/kernels/volk/volk_32fc_deinterleave_real_32f.h b/kernels/volk/volk_32fc_deinterleave_real_32f.h
++index 92a94d3..2526a16 100644
++--- a/kernels/volk/volk_32fc_deinterleave_real_32f.h
+++++ b/kernels/volk/volk_32fc_deinterleave_real_32f.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_deinterleave_real_32f(float* iBuffer, const lv_32fc_t* complexVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_deinterleave_real_32f(float* iBuffer, const lv_32fc_t* complexVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -76,96 +76,96 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_deinterleave_real_32f_a_avx2(float* iBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_real_32f_a_avx2(float* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- const float* complexVectorPtr = (const float*)complexVector;
++- float* iBufferPtr = iBuffer;
+++ const float* complexVectorPtr = (const float*)complexVector;
+++ float* iBufferPtr = iBuffer;
++
++- __m256 cplxValue1, cplxValue2;
++- __m256 iValue;
++- __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
++- for(;number < eighthPoints; number++){
+++ __m256 cplxValue1, cplxValue2;
+++ __m256 iValue;
+++ __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
+++ for (; number < eighthPoints; number++) {
++
++- cplxValue1 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ cplxValue1 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- cplxValue2 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ cplxValue2 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- // Arrange in i1i2i3i4 format
++- iValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
++- iValue = _mm256_permutevar8x32_ps(iValue,idx);
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
+++ iValue = _mm256_permutevar8x32_ps(iValue, idx);
++
++- _mm256_store_ps(iBufferPtr, iValue);
+++ _mm256_store_ps(iBufferPtr, iValue);
++
++- iBufferPtr += 8;
++- }
+++ iBufferPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32fc_deinterleave_real_32f_a_sse(float* iBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_real_32f_a_sse(float* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* complexVectorPtr = (const float*)complexVector;
++- float* iBufferPtr = iBuffer;
+++ const float* complexVectorPtr = (const float*)complexVector;
+++ float* iBufferPtr = iBuffer;
++
++- __m128 cplxValue1, cplxValue2, iValue;
++- for(;number < quarterPoints; number++){
+++ __m128 cplxValue1, cplxValue2, iValue;
+++ for (; number < quarterPoints; number++) {
++
++- cplxValue1 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ cplxValue1 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- cplxValue2 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ cplxValue2 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- // Arrange in i1i2i3i4 format
++- iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
++
++- _mm_store_ps(iBufferPtr, iValue);
+++ _mm_store_ps(iBufferPtr, iValue);
++
++- iBufferPtr += 4;
++- }
+++ iBufferPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_deinterleave_real_32f_generic(float* iBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_real_32f_generic(float* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const float* complexVectorPtr = (float*)complexVector;
++- float* iBufferPtr = iBuffer;
++- for(number = 0; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* iBufferPtr = iBuffer;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -173,27 +173,27 @@ volk_32fc_deinterleave_real_32f_generic(float* iBuffer, const lv_32fc_t* complex
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32fc_deinterleave_real_32f_neon(float* iBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_real_32f_neon(float* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- unsigned int quarter_points = num_points / 4;
++- const float* complexVectorPtr = (float*)complexVector;
++- float* iBufferPtr = iBuffer;
++- float32x4x2_t complexInput;
++-
++- for(number = 0; number < quarter_points; number++){
++- complexInput = vld2q_f32(complexVectorPtr);
++- vst1q_f32( iBufferPtr, complexInput.val[0] );
++- complexVectorPtr += 8;
++- iBufferPtr += 4;
++- }
++-
++- for(number = quarter_points*4; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ unsigned int quarter_points = num_points / 4;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* iBufferPtr = iBuffer;
+++ float32x4x2_t complexInput;
+++
+++ for (number = 0; number < quarter_points; number++) {
+++ complexInput = vld2q_f32(complexVectorPtr);
+++ vst1q_f32(iBufferPtr, complexInput.val[0]);
+++ complexVectorPtr += 8;
+++ iBufferPtr += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++@@ -209,41 +209,41 @@ volk_32fc_deinterleave_real_32f_neon(float* iBuffer, const lv_32fc_t* complexVec
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_deinterleave_real_32f_u_avx2(float* iBuffer, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_deinterleave_real_32f_u_avx2(float* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- const float* complexVectorPtr = (const float*)complexVector;
++- float* iBufferPtr = iBuffer;
+++ const float* complexVectorPtr = (const float*)complexVector;
+++ float* iBufferPtr = iBuffer;
++
++- __m256 cplxValue1, cplxValue2;
++- __m256 iValue;
++- __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
++- for(;number < eighthPoints; number++){
+++ __m256 cplxValue1, cplxValue2;
+++ __m256 iValue;
+++ __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
+++ for (; number < eighthPoints; number++) {
++
++- cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- cplxValue2 = _mm256_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ cplxValue2 = _mm256_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- // Arrange in i1i2i3i4 format
++- iValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
++- iValue = _mm256_permutevar8x32_ps(iValue,idx);
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
+++ iValue = _mm256_permutevar8x32_ps(iValue, idx);
++
++- _mm256_storeu_ps(iBufferPtr, iValue);
+++ _mm256_storeu_ps(iBufferPtr, iValue);
++
++- iBufferPtr += 8;
++- }
+++ iBufferPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_32fc_deinterleave_real_64f.h b/kernels/volk/volk_32fc_deinterleave_real_64f.h
++index 3d6e901..9ec7769 100644
++--- a/kernels/volk/volk_32fc_deinterleave_real_64f.h
+++++ b/kernels/volk/volk_32fc_deinterleave_real_64f.h
++@@ -77,124 +77,132 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void volk_32fc_deinterleave_real_64f_a_avx2(
++- double *iBuffer, const lv_32fc_t *complexVector, unsigned int num_points) {
++- unsigned int number = 0;
++-
++- const float *complexVectorPtr = (float *)complexVector;
++- double *iBufferPtr = iBuffer;
++-
++- const unsigned int quarterPoints = num_points / 4;
++- __m256 cplxValue;
++- __m128 fVal;
++- __m256d dVal;
++- __m256i idx = _mm256_set_epi32(0, 0, 0, 0, 6, 4, 2, 0);
++- for (; number < quarterPoints; number++) {
++-
++- cplxValue = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- // Arrange in i1i2i1i2 format
++- cplxValue = _mm256_permutevar8x32_ps(cplxValue, idx);
++- fVal = _mm256_extractf128_ps(cplxValue, 0);
++- dVal = _mm256_cvtps_pd(fVal);
++- _mm256_store_pd(iBufferPtr, dVal);
++-
++- iBufferPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for (; number < num_points; number++) {
++- *iBufferPtr++ = (double)*complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++static inline void volk_32fc_deinterleave_real_64f_a_avx2(double* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ double* iBufferPtr = iBuffer;
+++
+++ const unsigned int quarterPoints = num_points / 4;
+++ __m256 cplxValue;
+++ __m128 fVal;
+++ __m256d dVal;
+++ __m256i idx = _mm256_set_epi32(0, 0, 0, 0, 6, 4, 2, 0);
+++ for (; number < quarterPoints; number++) {
+++
+++ cplxValue = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ // Arrange in i1i2i1i2 format
+++ cplxValue = _mm256_permutevar8x32_ps(cplxValue, idx);
+++ fVal = _mm256_extractf128_ps(cplxValue, 0);
+++ dVal = _mm256_cvtps_pd(fVal);
+++ _mm256_store_pd(iBufferPtr, dVal);
+++
+++ iBufferPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (double)*complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_32fc_deinterleave_real_64f_a_sse2(
++- double *iBuffer, const lv_32fc_t *complexVector, unsigned int num_points) {
++- unsigned int number = 0;
+++static inline void volk_32fc_deinterleave_real_64f_a_sse2(double* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
++
++- const float *complexVectorPtr = (float *)complexVector;
++- double *iBufferPtr = iBuffer;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ double* iBufferPtr = iBuffer;
++
++- const unsigned int halfPoints = num_points / 2;
++- __m128 cplxValue, fVal;
++- __m128d dVal;
++- for (; number < halfPoints; number++) {
+++ const unsigned int halfPoints = num_points / 2;
+++ __m128 cplxValue, fVal;
+++ __m128d dVal;
+++ for (; number < halfPoints; number++) {
++
++- cplxValue = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ cplxValue = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- // Arrange in i1i2i1i2 format
++- fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(2, 0, 2, 0));
++- dVal = _mm_cvtps_pd(fVal);
++- _mm_store_pd(iBufferPtr, dVal);
+++ // Arrange in i1i2i1i2 format
+++ fVal = _mm_shuffle_ps(cplxValue, cplxValue, _MM_SHUFFLE(2, 0, 2, 0));
+++ dVal = _mm_cvtps_pd(fVal);
+++ _mm_store_pd(iBufferPtr, dVal);
++
++- iBufferPtr += 2;
++- }
+++ iBufferPtr += 2;
+++ }
++
++- number = halfPoints * 2;
++- for (; number < num_points; number++) {
++- *iBufferPtr++ = (double)*complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ number = halfPoints * 2;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (double)*complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32fc_deinterleave_real_64f_generic(
++- double *iBuffer, const lv_32fc_t *complexVector, unsigned int num_points) {
++- unsigned int number = 0;
++- const float *complexVectorPtr = (float *)complexVector;
++- double *iBufferPtr = iBuffer;
++- for (number = 0; number < num_points; number++) {
++- *iBufferPtr++ = (double)*complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++static inline void volk_32fc_deinterleave_real_64f_generic(double* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ double* iBufferPtr = iBuffer;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = (double)*complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_NEONV8
++ #include <arm_neon.h>
++
++-static inline void volk_32fc_deinterleave_real_64f_neon(
++- double *iBuffer, const lv_32fc_t *complexVector, unsigned int num_points) {
++- unsigned int number = 0;
++- unsigned int quarter_points = num_points / 4;
++- const float *complexVectorPtr = (float *)complexVector;
++- double *iBufferPtr = iBuffer;
++- float32x2x4_t complexInput;
++- float64x2_t iVal1;
++- float64x2_t iVal2;
++- float64x2x2_t iVal;
++-
++- for (number = 0; number < quarter_points; number++) {
++- // Load data into register
++- complexInput = vld4_f32(complexVectorPtr);
++-
++- // Perform single to double precision conversion
++- iVal1 = vcvt_f64_f32(complexInput.val[0]);
++- iVal2 = vcvt_f64_f32(complexInput.val[2]);
++- iVal.val[0] = iVal1;
++- iVal.val[1] = iVal2;
++-
++- // Store results into memory buffer
++- vst2q_f64(iBufferPtr, iVal);
++-
++- // Update pointers
++- iBufferPtr += 4;
++- complexVectorPtr += 8;
++- }
++-
++- for (number = quarter_points * 4; number < num_points; number++) {
++- *iBufferPtr++ = (double)*complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++static inline void volk_32fc_deinterleave_real_64f_neon(double* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ unsigned int quarter_points = num_points / 4;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ double* iBufferPtr = iBuffer;
+++ float32x2x4_t complexInput;
+++ float64x2_t iVal1;
+++ float64x2_t iVal2;
+++ float64x2x2_t iVal;
+++
+++ for (number = 0; number < quarter_points; number++) {
+++ // Load data into register
+++ complexInput = vld4_f32(complexVectorPtr);
+++
+++ // Perform single to double precision conversion
+++ iVal1 = vcvt_f64_f32(complexInput.val[0]);
+++ iVal2 = vcvt_f64_f32(complexInput.val[2]);
+++ iVal.val[0] = iVal1;
+++ iVal.val[1] = iVal2;
+++
+++ // Store results into memory buffer
+++ vst2q_f64(iBufferPtr, iVal);
+++
+++ // Update pointers
+++ iBufferPtr += 4;
+++ complexVectorPtr += 8;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ *iBufferPtr++ = (double)*complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++@@ -209,37 +217,39 @@ static inline void volk_32fc_deinterleave_real_64f_neon(
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void volk_32fc_deinterleave_real_64f_u_avx2(
++- double *iBuffer, const lv_32fc_t *complexVector, unsigned int num_points) {
++- unsigned int number = 0;
++-
++- const float *complexVectorPtr = (float *)complexVector;
++- double *iBufferPtr = iBuffer;
++-
++- const unsigned int quarterPoints = num_points / 4;
++- __m256 cplxValue;
++- __m128 fVal;
++- __m256d dVal;
++- __m256i idx = _mm256_set_epi32(0, 0, 0, 0, 6, 4, 2, 0);
++- for (; number < quarterPoints; number++) {
++-
++- cplxValue = _mm256_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- // Arrange in i1i2i1i2 format
++- cplxValue = _mm256_permutevar8x32_ps(cplxValue, idx);
++- fVal = _mm256_extractf128_ps(cplxValue, 0);
++- dVal = _mm256_cvtps_pd(fVal);
++- _mm256_storeu_pd(iBufferPtr, dVal);
++-
++- iBufferPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for (; number < num_points; number++) {
++- *iBufferPtr++ = (double)*complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++static inline void volk_32fc_deinterleave_real_64f_u_avx2(double* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ double* iBufferPtr = iBuffer;
+++
+++ const unsigned int quarterPoints = num_points / 4;
+++ __m256 cplxValue;
+++ __m128 fVal;
+++ __m256d dVal;
+++ __m256i idx = _mm256_set_epi32(0, 0, 0, 0, 6, 4, 2, 0);
+++ for (; number < quarterPoints; number++) {
+++
+++ cplxValue = _mm256_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ // Arrange in i1i2i1i2 format
+++ cplxValue = _mm256_permutevar8x32_ps(cplxValue, idx);
+++ fVal = _mm256_extractf128_ps(cplxValue, 0);
+++ dVal = _mm256_cvtps_pd(fVal);
+++ _mm256_storeu_pd(iBufferPtr, dVal);
+++
+++ iBufferPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (double)*complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_32fc_index_max_16u.h b/kernels/volk/volk_32fc_index_max_16u.h
++index a9f9508..b9f9cfd 100644
++--- a/kernels/volk/volk_32fc_index_max_16u.h
+++++ b/kernels/volk/volk_32fc_index_max_16u.h
++@@ -76,346 +76,353 @@
++ #ifndef INCLUDED_volk_32fc_index_max_16u_a_H
++ #define INCLUDED_volk_32fc_index_max_16u_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <limits.h>
+++#include <stdio.h>
+++#include <volk/volk_common.h>
++ #include <volk/volk_complex.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++ static inline void
++-volk_32fc_index_max_16u_a_avx2(uint16_t* target, lv_32fc_t* src0,
++- uint32_t num_points)
+++volk_32fc_index_max_16u_a_avx2(uint16_t* target, lv_32fc_t* src0, uint32_t num_points)
++ {
++- num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
++- // Branchless version, if we think it'll make a difference
++- //num_points = USHRT_MAX ^ ((num_points ^ USHRT_MAX) & -(num_points < USHRT_MAX));
++-
++- const uint32_t num_bytes = num_points*8;
++-
++- union bit256 holderf;
++- union bit256 holderi;
++- float sq_dist = 0.0;
+++ num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
+++ // Branchless version, if we think it'll make a difference
+++ // num_points = USHRT_MAX ^ ((num_points ^ USHRT_MAX) & -(num_points < USHRT_MAX));
++
++- union bit256 xmm5, xmm4;
++- __m256 xmm1, xmm2, xmm3;
++- __m256i xmm8, xmm11, xmm12, xmmfive, xmmfour, xmm9, holder0, holder1, xmm10;
+++ const uint32_t num_bytes = num_points * 8;
++
++- xmm5.int_vec = xmmfive = _mm256_setzero_si256();
++- xmm4.int_vec = xmmfour = _mm256_setzero_si256();
++- holderf.int_vec = holder0 = _mm256_setzero_si256();
++- holderi.int_vec = holder1 = _mm256_setzero_si256();
+++ union bit256 holderf;
+++ union bit256 holderi;
+++ float sq_dist = 0.0;
++
++- int bound = num_bytes >> 6;
++- int i = 0;
+++ union bit256 xmm5, xmm4;
+++ __m256 xmm1, xmm2, xmm3;
+++ __m256i xmm8, xmm11, xmm12, xmmfive, xmmfour, xmm9, holder0, holder1, xmm10;
++
++- xmm8 = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
++- xmm9 = _mm256_setzero_si256(); //=xmm8
++- xmm10 = _mm256_set1_epi32(8);
++- xmm3 = _mm256_setzero_ps();
+++ xmm5.int_vec = xmmfive = _mm256_setzero_si256();
+++ xmm4.int_vec = xmmfour = _mm256_setzero_si256();
+++ holderf.int_vec = holder0 = _mm256_setzero_si256();
+++ holderi.int_vec = holder1 = _mm256_setzero_si256();
++
++- __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
++- for(; i < bound; ++i) {
++- xmm1 = _mm256_load_ps((float*)src0);
++- xmm2 = _mm256_load_ps((float*)&src0[4]);
+++ int bound = num_bytes >> 6;
+++ int i = 0;
++
++- src0 += 8;
+++ xmm8 = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
+++ xmm9 = _mm256_setzero_si256(); //=xmm8
+++ xmm10 = _mm256_set1_epi32(8);
+++ xmm3 = _mm256_setzero_ps();
++
++- xmm1 = _mm256_mul_ps(xmm1, xmm1);
++- xmm2 = _mm256_mul_ps(xmm2, xmm2);
+++ __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
+++ for (; i < bound; ++i) {
+++ xmm1 = _mm256_load_ps((float*)src0);
+++ xmm2 = _mm256_load_ps((float*)&src0[4]);
++
++- xmm1 = _mm256_hadd_ps(xmm1, xmm2);
++- xmm1 = _mm256_permutevar8x32_ps(xmm1, idx);
+++ src0 += 8;
++
++- xmm3 = _mm256_max_ps(xmm1, xmm3);
+++ xmm1 = _mm256_mul_ps(xmm1, xmm1);
+++ xmm2 = _mm256_mul_ps(xmm2, xmm2);
++
++- xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
++- xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
+++ xmm1 = _mm256_hadd_ps(xmm1, xmm2);
+++ xmm1 = _mm256_permutevar8x32_ps(xmm1, idx);
++
++- xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
++- xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
+++ xmm3 = _mm256_max_ps(xmm1, xmm3);
++
++- xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++ xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
+++ xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++
++- xmm8 = _mm256_add_epi32(xmm8, xmm10);
++- }
++- xmm10 = _mm256_set1_epi32(4);
++- if (num_bytes >> 5 & 1) {
++- xmm1 = _mm256_load_ps((float*)src0);
+++ xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
+++ xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
++
++- src0 += 4;
+++ xmm9 = _mm256_add_epi32(xmm11, xmm12);
++
++- xmm1 = _mm256_mul_ps(xmm1, xmm1);
+++ xmm8 = _mm256_add_epi32(xmm8, xmm10);
+++ }
+++ xmm10 = _mm256_set1_epi32(4);
+++ if (num_bytes >> 5 & 1) {
+++ xmm1 = _mm256_load_ps((float*)src0);
++
++- xmm1 = _mm256_hadd_ps(xmm1, xmm1);
++- xmm1 = _mm256_permutevar8x32_ps(xmm1, idx);
+++ src0 += 4;
++
++- xmm3 = _mm256_max_ps(xmm1, xmm3);
+++ xmm1 = _mm256_mul_ps(xmm1, xmm1);
++
++- xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
++- xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
+++ xmm1 = _mm256_hadd_ps(xmm1, xmm1);
+++ xmm1 = _mm256_permutevar8x32_ps(xmm1, idx);
++
++- xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
++- xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
+++ xmm3 = _mm256_max_ps(xmm1, xmm3);
++
++- xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++ xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
+++ xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++
++- xmm8 = _mm256_add_epi32(xmm8, xmm10);
++- }
+++ xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
+++ xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
++
++- idx = _mm256_set_epi32(1,0,1,0,1,0,1,0);
++- xmm10 = _mm256_set1_epi32(2);
++- if (num_bytes >> 4 & 1) {
++- xmm2 = _mm256_load_ps((float*)src0);
+++ xmm9 = _mm256_add_epi32(xmm11, xmm12);
++
++- xmm1 = _mm256_permutevar8x32_ps(bit256_p(&xmm8)->float_vec, idx);
++- xmm8 = bit256_p(&xmm1)->int_vec;
+++ xmm8 = _mm256_add_epi32(xmm8, xmm10);
+++ }
++
++- xmm2 = _mm256_mul_ps(xmm2, xmm2);
+++ idx = _mm256_set_epi32(1, 0, 1, 0, 1, 0, 1, 0);
+++ xmm10 = _mm256_set1_epi32(2);
+++ if (num_bytes >> 4 & 1) {
+++ xmm2 = _mm256_load_ps((float*)src0);
++
++- src0 += 2;
+++ xmm1 = _mm256_permutevar8x32_ps(bit256_p(&xmm8)->float_vec, idx);
+++ xmm8 = bit256_p(&xmm1)->int_vec;
++
++- xmm1 = _mm256_hadd_ps(xmm2, xmm2);
+++ xmm2 = _mm256_mul_ps(xmm2, xmm2);
++
++- xmm3 = _mm256_max_ps(xmm1, xmm3);
+++ src0 += 2;
++
++- xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
++- xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++-
++- xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
++- xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
+++ xmm1 = _mm256_hadd_ps(xmm2, xmm2);
++
++- xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++ xmm3 = _mm256_max_ps(xmm1, xmm3);
++
++- xmm8 = _mm256_add_epi32(xmm8, xmm10);
++- }
+++ xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
+++ xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++
++- /*
++- idx = _mm256_setzero_si256();
++- for(i = 0; i < leftovers2; ++i) {
++- //printf("%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1], ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);
+++ xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
+++ xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
++
++- sq_dist = lv_creal(src0[0]) * lv_creal(src0[0]) + lv_cimag(src0[0]) * lv_cimag(src0[0]);
+++ xmm9 = _mm256_add_epi32(xmm11, xmm12);
++
++- //xmm = _mm_load1_ps(&sq_dist);//insert?
++- xmm2 = _mm256_set1_ps(sq_dist);
++- //xmm2 = _mm256_insertf128_ps(xmm2, xmm, 0);
+++ xmm8 = _mm256_add_epi32(xmm8, xmm10);
+++ }
++
++- xmm1 = xmm3;
+++ /*
+++ idx = _mm256_setzero_si256();
+++ for(i = 0; i < leftovers2; ++i) {
+++ //printf("%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1],
+++ ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);
++
++- xmm3 = _mm256_max_ps(xmm3, xmm2);//only lowest 32bit value
++- xmm3 = _mm256_permutevar8x32_ps(xmm3, idx);
+++ sq_dist = lv_creal(src0[0]) * lv_creal(src0[0]) + lv_cimag(src0[0]) *
+++ lv_cimag(src0[0]);
++
++- xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
++- xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
+++ //xmm = _mm_load1_ps(&sq_dist);//insert?
+++ xmm2 = _mm256_set1_ps(sq_dist);
+++ //xmm2 = _mm256_insertf128_ps(xmm2, xmm, 0);
++
++- xmm8 = _mm256_permutevar8x32_epi32(xmm8, idx);
+++ xmm1 = xmm3;
++
++- xmm11 = _mm256_and_si256(xmm8, xmm4.int_vec);
++- xmm12 = _mm256_and_si256(xmm9, xmm5.int_vec);
+++ xmm3 = _mm256_max_ps(xmm3, xmm2);//only lowest 32bit value
+++ xmm3 = _mm256_permutevar8x32_ps(xmm3, idx);
++
++- xmm9 = _mm256_add_epi32(xmm11, xmm12);
++-}*/
+++ xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
+++ xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++
++- _mm256_store_ps((float*)&(holderf.f), xmm3);
++- _mm256_store_si256(&(holderi.int_vec), xmm9);
+++ xmm8 = _mm256_permutevar8x32_epi32(xmm8, idx);
++
++- target[0] = holderi.i[0];
++- sq_dist = holderf.f[0];
++- target[0] = (holderf.f[1] > sq_dist) ? holderi.i[1] : target[0];
++- sq_dist = (holderf.f[1] > sq_dist) ? holderf.f[1] : sq_dist;
++- target[0] = (holderf.f[2] > sq_dist) ? holderi.i[2] : target[0];
++- sq_dist = (holderf.f[2] > sq_dist) ? holderf.f[2] : sq_dist;
++- target[0] = (holderf.f[3] > sq_dist) ? holderi.i[3] : target[0];
++- sq_dist = (holderf.f[3] > sq_dist) ? holderf.f[3] : sq_dist;
++- target[0] = (holderf.f[4] > sq_dist) ? holderi.i[4] : target[0];
++- sq_dist = (holderf.f[4] > sq_dist) ? holderf.f[4] : sq_dist;
++- target[0] = (holderf.f[5] > sq_dist) ? holderi.i[5] : target[0];
++- sq_dist = (holderf.f[5] > sq_dist) ? holderf.f[5] : sq_dist;
++- target[0] = (holderf.f[6] > sq_dist) ? holderi.i[6] : target[0];
++- sq_dist = (holderf.f[6] > sq_dist) ? holderf.f[6] : sq_dist;
++- target[0] = (holderf.f[7] > sq_dist) ? holderi.i[7] : target[0];
++- sq_dist = (holderf.f[7] > sq_dist) ? holderf.f[7] : sq_dist;
+++ xmm11 = _mm256_and_si256(xmm8, xmm4.int_vec);
+++ xmm12 = _mm256_and_si256(xmm9, xmm5.int_vec);
++
+++ xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++ }*/
+++
+++ _mm256_store_ps((float*)&(holderf.f), xmm3);
+++ _mm256_store_si256(&(holderi.int_vec), xmm9);
+++
+++ target[0] = holderi.i[0];
+++ sq_dist = holderf.f[0];
+++ target[0] = (holderf.f[1] > sq_dist) ? holderi.i[1] : target[0];
+++ sq_dist = (holderf.f[1] > sq_dist) ? holderf.f[1] : sq_dist;
+++ target[0] = (holderf.f[2] > sq_dist) ? holderi.i[2] : target[0];
+++ sq_dist = (holderf.f[2] > sq_dist) ? holderf.f[2] : sq_dist;
+++ target[0] = (holderf.f[3] > sq_dist) ? holderi.i[3] : target[0];
+++ sq_dist = (holderf.f[3] > sq_dist) ? holderf.f[3] : sq_dist;
+++ target[0] = (holderf.f[4] > sq_dist) ? holderi.i[4] : target[0];
+++ sq_dist = (holderf.f[4] > sq_dist) ? holderf.f[4] : sq_dist;
+++ target[0] = (holderf.f[5] > sq_dist) ? holderi.i[5] : target[0];
+++ sq_dist = (holderf.f[5] > sq_dist) ? holderf.f[5] : sq_dist;
+++ target[0] = (holderf.f[6] > sq_dist) ? holderi.i[6] : target[0];
+++ sq_dist = (holderf.f[6] > sq_dist) ? holderf.f[6] : sq_dist;
+++ target[0] = (holderf.f[7] > sq_dist) ? holderi.i[7] : target[0];
+++ sq_dist = (holderf.f[7] > sq_dist) ? holderf.f[7] : sq_dist;
++ }
++
++ #endif /*LV_HAVE_AVX2*/
++
++ #ifdef LV_HAVE_SSE3
++-#include <xmmintrin.h>
++ #include <pmmintrin.h>
+++#include <xmmintrin.h>
++
++ static inline void
++-volk_32fc_index_max_16u_a_sse3(uint16_t* target, lv_32fc_t* src0,
++- uint32_t num_points)
+++volk_32fc_index_max_16u_a_sse3(uint16_t* target, lv_32fc_t* src0, uint32_t num_points)
++ {
++- num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
++- // Branchless version, if we think it'll make a difference
++- //num_points = USHRT_MAX ^ ((num_points ^ USHRT_MAX) & -(num_points < USHRT_MAX));
+++ num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
+++ // Branchless version, if we think it'll make a difference
+++ // num_points = USHRT_MAX ^ ((num_points ^ USHRT_MAX) & -(num_points < USHRT_MAX));
++
++- const uint32_t num_bytes = num_points*8;
+++ const uint32_t num_bytes = num_points * 8;
++
++- union bit128 holderf;
++- union bit128 holderi;
++- float sq_dist = 0.0;
+++ union bit128 holderf;
+++ union bit128 holderi;
+++ float sq_dist = 0.0;
++
++- union bit128 xmm5, xmm4;
++- __m128 xmm1, xmm2, xmm3;
++- __m128i xmm8, xmm11, xmm12, xmmfive, xmmfour, xmm9, holder0, holder1, xmm10;
+++ union bit128 xmm5, xmm4;
+++ __m128 xmm1, xmm2, xmm3;
+++ __m128i xmm8, xmm11, xmm12, xmmfive, xmmfour, xmm9, holder0, holder1, xmm10;
++
++- xmm5.int_vec = xmmfive = _mm_setzero_si128();
++- xmm4.int_vec = xmmfour = _mm_setzero_si128();
++- holderf.int_vec = holder0 = _mm_setzero_si128();
++- holderi.int_vec = holder1 = _mm_setzero_si128();
+++ xmm5.int_vec = xmmfive = _mm_setzero_si128();
+++ xmm4.int_vec = xmmfour = _mm_setzero_si128();
+++ holderf.int_vec = holder0 = _mm_setzero_si128();
+++ holderi.int_vec = holder1 = _mm_setzero_si128();
++
++- int bound = num_bytes >> 5;
++- int i = 0;
+++ int bound = num_bytes >> 5;
+++ int i = 0;
++
++- xmm8 = _mm_set_epi32(3, 2, 1, 0);//remember the crazy reverse order!
++- xmm9 = _mm_setzero_si128();
++- xmm10 = _mm_set_epi32(4, 4, 4, 4);
++- xmm3 = _mm_setzero_ps();
++- //printf("%f, %f, %f, %f\n", ((float*)&xmm10)[0], ((float*)&xmm10)[1], ((float*)&xmm10)[2], ((float*)&xmm10)[3]);
+++ xmm8 = _mm_set_epi32(3, 2, 1, 0); // remember the crazy reverse order!
+++ xmm9 = _mm_setzero_si128();
+++ xmm10 = _mm_set_epi32(4, 4, 4, 4);
+++ xmm3 = _mm_setzero_ps();
+++ // printf("%f, %f, %f, %f\n", ((float*)&xmm10)[0], ((float*)&xmm10)[1],
+++ // ((float*)&xmm10)[2], ((float*)&xmm10)[3]);
++
++- for(; i < bound; ++i) {
++- xmm1 = _mm_load_ps((float*)src0);
++- xmm2 = _mm_load_ps((float*)&src0[2]);
+++ for (; i < bound; ++i) {
+++ xmm1 = _mm_load_ps((float*)src0);
+++ xmm2 = _mm_load_ps((float*)&src0[2]);
++
++- src0 += 4;
+++ src0 += 4;
++
++- xmm1 = _mm_mul_ps(xmm1, xmm1);
++- xmm2 = _mm_mul_ps(xmm2, xmm2);
+++ xmm1 = _mm_mul_ps(xmm1, xmm1);
+++ xmm2 = _mm_mul_ps(xmm2, xmm2);
++
++- xmm1 = _mm_hadd_ps(xmm1, xmm2);
+++ xmm1 = _mm_hadd_ps(xmm1, xmm2);
++
++- xmm3 = _mm_max_ps(xmm1, xmm3);
+++ xmm3 = _mm_max_ps(xmm1, xmm3);
++
++- xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);
++- xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);
+++ xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);
+++ xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);
++
++- xmm11 = _mm_and_si128(xmm8, xmm5.int_vec);
++- xmm12 = _mm_and_si128(xmm9, xmm4.int_vec);
+++ xmm11 = _mm_and_si128(xmm8, xmm5.int_vec);
+++ xmm12 = _mm_and_si128(xmm9, xmm4.int_vec);
++
++- xmm9 = _mm_add_epi32(xmm11, xmm12);
+++ xmm9 = _mm_add_epi32(xmm11, xmm12);
++
++- xmm8 = _mm_add_epi32(xmm8, xmm10);
+++ xmm8 = _mm_add_epi32(xmm8, xmm10);
++
++- //printf("%f, %f, %f, %f\n", ((float*)&xmm3)[0], ((float*)&xmm3)[1], ((float*)&xmm3)[2], ((float*)&xmm3)[3]);
++- //printf("%u, %u, %u, %u\n", ((uint32_t*)&xmm10)[0], ((uint32_t*)&xmm10)[1], ((uint32_t*)&xmm10)[2], ((uint32_t*)&xmm10)[3]);
++- }
+++ // printf("%f, %f, %f, %f\n", ((float*)&xmm3)[0], ((float*)&xmm3)[1],
+++ // ((float*)&xmm3)[2], ((float*)&xmm3)[3]); printf("%u, %u, %u, %u\n",
+++ // ((uint32_t*)&xmm10)[0], ((uint32_t*)&xmm10)[1], ((uint32_t*)&xmm10)[2],
+++ // ((uint32_t*)&xmm10)[3]);
+++ }
++
++
++- if (num_bytes >> 4 & 1) {
++- xmm2 = _mm_load_ps((float*)src0);
+++ if (num_bytes >> 4 & 1) {
+++ xmm2 = _mm_load_ps((float*)src0);
++
++- xmm1 = _mm_movelh_ps(bit128_p(&xmm8)->float_vec, bit128_p(&xmm8)->float_vec);
++- xmm8 = bit128_p(&xmm1)->int_vec;
+++ xmm1 = _mm_movelh_ps(bit128_p(&xmm8)->float_vec, bit128_p(&xmm8)->float_vec);
+++ xmm8 = bit128_p(&xmm1)->int_vec;
++
++- xmm2 = _mm_mul_ps(xmm2, xmm2);
+++ xmm2 = _mm_mul_ps(xmm2, xmm2);
++
++- src0 += 2;
+++ src0 += 2;
++
++- xmm1 = _mm_hadd_ps(xmm2, xmm2);
+++ xmm1 = _mm_hadd_ps(xmm2, xmm2);
++
++- xmm3 = _mm_max_ps(xmm1, xmm3);
+++ xmm3 = _mm_max_ps(xmm1, xmm3);
++
++- xmm10 = _mm_set_epi32(2, 2, 2, 2);//load1_ps((float*)&init[2]);
+++ xmm10 = _mm_set_epi32(2, 2, 2, 2); // load1_ps((float*)&init[2]);
++
++- xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);
++- xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);
+++ xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);
+++ xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);
++
++- xmm11 = _mm_and_si128(xmm8, xmm5.int_vec);
++- xmm12 = _mm_and_si128(xmm9, xmm4.int_vec);
+++ xmm11 = _mm_and_si128(xmm8, xmm5.int_vec);
+++ xmm12 = _mm_and_si128(xmm9, xmm4.int_vec);
++
++- xmm9 = _mm_add_epi32(xmm11, xmm12);
+++ xmm9 = _mm_add_epi32(xmm11, xmm12);
++
++- xmm8 = _mm_add_epi32(xmm8, xmm10);
++- //printf("egads%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1], ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);
++- }
+++ xmm8 = _mm_add_epi32(xmm8, xmm10);
+++ // printf("egads%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1],
+++ // ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);
+++ }
++
++- if (num_bytes >> 3 & 1) {
++- //printf("%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1], ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);
+++ if (num_bytes >> 3 & 1) {
+++ // printf("%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1],
+++ // ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);
++
++- sq_dist = lv_creal(src0[0]) * lv_creal(src0[0]) + lv_cimag(src0[0]) * lv_cimag(src0[0]);
+++ sq_dist =
+++ lv_creal(src0[0]) * lv_creal(src0[0]) + lv_cimag(src0[0]) * lv_cimag(src0[0]);
++
++- xmm2 = _mm_load1_ps(&sq_dist);
+++ xmm2 = _mm_load1_ps(&sq_dist);
++
++- xmm1 = xmm3;
+++ xmm1 = xmm3;
++
++- xmm3 = _mm_max_ss(xmm3, xmm2);
+++ xmm3 = _mm_max_ss(xmm3, xmm2);
++
++- xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);
++- xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);
+++ xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);
+++ xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);
++
++- xmm8 = _mm_shuffle_epi32(xmm8, 0x00);
+++ xmm8 = _mm_shuffle_epi32(xmm8, 0x00);
++
++- xmm11 = _mm_and_si128(xmm8, xmm4.int_vec);
++- xmm12 = _mm_and_si128(xmm9, xmm5.int_vec);
+++ xmm11 = _mm_and_si128(xmm8, xmm4.int_vec);
+++ xmm12 = _mm_and_si128(xmm9, xmm5.int_vec);
++
++- xmm9 = _mm_add_epi32(xmm11, xmm12);
++- }
+++ xmm9 = _mm_add_epi32(xmm11, xmm12);
+++ }
++
++- //printf("%f, %f, %f, %f\n", ((float*)&xmm3)[0], ((float*)&xmm3)[1], ((float*)&xmm3)[2], ((float*)&xmm3)[3]);
++- //printf("%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1], ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);
+++ // printf("%f, %f, %f, %f\n", ((float*)&xmm3)[0], ((float*)&xmm3)[1],
+++ // ((float*)&xmm3)[2], ((float*)&xmm3)[3]); printf("%u, %u, %u, %u\n",
+++ // ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1], ((uint32_t*)&xmm9)[2],
+++ // ((uint32_t*)&xmm9)[3]);
++
++- _mm_store_ps((float*)&(holderf.f), xmm3);
++- _mm_store_si128(&(holderi.int_vec), xmm9);
+++ _mm_store_ps((float*)&(holderf.f), xmm3);
+++ _mm_store_si128(&(holderi.int_vec), xmm9);
++
++- target[0] = holderi.i[0];
++- sq_dist = holderf.f[0];
++- target[0] = (holderf.f[1] > sq_dist) ? holderi.i[1] : target[0];
++- sq_dist = (holderf.f[1] > sq_dist) ? holderf.f[1] : sq_dist;
++- target[0] = (holderf.f[2] > sq_dist) ? holderi.i[2] : target[0];
++- sq_dist = (holderf.f[2] > sq_dist) ? holderf.f[2] : sq_dist;
++- target[0] = (holderf.f[3] > sq_dist) ? holderi.i[3] : target[0];
++- sq_dist = (holderf.f[3] > sq_dist) ? holderf.f[3] : sq_dist;
+++ target[0] = holderi.i[0];
+++ sq_dist = holderf.f[0];
+++ target[0] = (holderf.f[1] > sq_dist) ? holderi.i[1] : target[0];
+++ sq_dist = (holderf.f[1] > sq_dist) ? holderf.f[1] : sq_dist;
+++ target[0] = (holderf.f[2] > sq_dist) ? holderi.i[2] : target[0];
+++ sq_dist = (holderf.f[2] > sq_dist) ? holderf.f[2] : sq_dist;
+++ target[0] = (holderf.f[3] > sq_dist) ? holderi.i[3] : target[0];
+++ sq_dist = (holderf.f[3] > sq_dist) ? holderf.f[3] : sq_dist;
++
++- /*
++- float placeholder = 0.0;
++- uint32_t temp0, temp1;
++- uint32_t g0 = (((float*)&xmm3)[0] > ((float*)&xmm3)[1]);
++- uint32_t l0 = g0 ^ 1;
+++ /*
+++ float placeholder = 0.0;
+++ uint32_t temp0, temp1;
+++ uint32_t g0 = (((float*)&xmm3)[0] > ((float*)&xmm3)[1]);
+++ uint32_t l0 = g0 ^ 1;
++
++- uint32_t g1 = (((float*)&xmm3)[1] > ((float*)&xmm3)[2]);
++- uint32_t l1 = g1 ^ 1;
+++ uint32_t g1 = (((float*)&xmm3)[1] > ((float*)&xmm3)[2]);
+++ uint32_t l1 = g1 ^ 1;
++
++- temp0 = g0 * ((uint32_t*)&xmm9)[0] + l0 * ((uint32_t*)&xmm9)[1];
++- temp1 = g0 * ((uint32_t*)&xmm9)[2] + l0 * ((uint32_t*)&xmm9)[3];
++- sq_dist = g0 * ((float*)&xmm3)[0] + l0 * ((float*)&xmm3)[1];
++- placeholder = g0 * ((float*)&xmm3)[2] + l0 * ((float*)&xmm3)[3];
+++ temp0 = g0 * ((uint32_t*)&xmm9)[0] + l0 * ((uint32_t*)&xmm9)[1];
+++ temp1 = g0 * ((uint32_t*)&xmm9)[2] + l0 * ((uint32_t*)&xmm9)[3];
+++ sq_dist = g0 * ((float*)&xmm3)[0] + l0 * ((float*)&xmm3)[1];
+++ placeholder = g0 * ((float*)&xmm3)[2] + l0 * ((float*)&xmm3)[3];
++
++- g0 = (sq_dist > placeholder);
++- l0 = g0 ^ 1;
++- target[0] = g0 * temp0 + l0 * temp1;
++- */
+++ g0 = (sq_dist > placeholder);
+++ l0 = g0 ^ 1;
+++ target[0] = g0 * temp0 + l0 * temp1;
+++ */
++ }
++
++ #endif /*LV_HAVE_SSE3*/
++
++ #ifdef LV_HAVE_GENERIC
++ static inline void
++- volk_32fc_index_max_16u_generic(uint16_t* target, lv_32fc_t* src0,
++- uint32_t num_points)
+++volk_32fc_index_max_16u_generic(uint16_t* target, lv_32fc_t* src0, uint32_t num_points)
++ {
++- num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
+++ num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
++
++- const uint32_t num_bytes = num_points*8;
+++ const uint32_t num_bytes = num_points * 8;
++
++- float sq_dist = 0.0;
++- float max = 0.0;
++- uint16_t index = 0;
+++ float sq_dist = 0.0;
+++ float max = 0.0;
+++ uint16_t index = 0;
++
++- uint32_t i = 0;
+++ uint32_t i = 0;
++
++- for(; i < num_bytes >> 3; ++i) {
++- sq_dist = lv_creal(src0[i]) * lv_creal(src0[i]) + lv_cimag(src0[i]) * lv_cimag(src0[i]);
+++ for (; i<num_bytes>> 3; ++i) {
+++ sq_dist =
+++ lv_creal(src0[i]) * lv_creal(src0[i]) + lv_cimag(src0[i]) * lv_cimag(src0[i]);
++
++- index = sq_dist > max ? i : index;
++- max = sq_dist > max ? sq_dist : max;
++- }
++- target[0] = index;
+++ index = sq_dist > max ? i : index;
+++ max = sq_dist > max ? sq_dist : max;
+++ }
+++ target[0] = index;
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -427,142 +434,140 @@ static inline void
++ #ifndef INCLUDED_volk_32fc_index_max_16u_u_H
++ #define INCLUDED_volk_32fc_index_max_16u_u_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <limits.h>
+++#include <stdio.h>
+++#include <volk/volk_common.h>
++ #include <volk/volk_complex.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++ static inline void
++-volk_32fc_index_max_16u_u_avx2(uint16_t* target, lv_32fc_t* src0,
++- uint32_t num_points)
+++volk_32fc_index_max_16u_u_avx2(uint16_t* target, lv_32fc_t* src0, uint32_t num_points)
++ {
++- num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
++- // Branchless version, if we think it'll make a difference
++- //num_points = USHRT_MAX ^ ((num_points ^ USHRT_MAX) & -(num_points < USHRT_MAX));
+++ num_points = (num_points > USHRT_MAX) ? USHRT_MAX : num_points;
+++ // Branchless version, if we think it'll make a difference
+++ // num_points = USHRT_MAX ^ ((num_points ^ USHRT_MAX) & -(num_points < USHRT_MAX));
++
++- const uint32_t num_bytes = num_points*8;
+++ const uint32_t num_bytes = num_points * 8;
++
++- union bit256 holderf;
++- union bit256 holderi;
++- float sq_dist = 0.0;
+++ union bit256 holderf;
+++ union bit256 holderi;
+++ float sq_dist = 0.0;
++
++- union bit256 xmm5, xmm4;
++- __m256 xmm1, xmm2, xmm3;
++- __m256i xmm8, xmm11, xmm12, xmmfive, xmmfour, xmm9, holder0, holder1, xmm10;
+++ union bit256 xmm5, xmm4;
+++ __m256 xmm1, xmm2, xmm3;
+++ __m256i xmm8, xmm11, xmm12, xmmfive, xmmfour, xmm9, holder0, holder1, xmm10;
++
++- xmm5.int_vec = xmmfive = _mm256_setzero_si256();
++- xmm4.int_vec = xmmfour = _mm256_setzero_si256();
++- holderf.int_vec = holder0 = _mm256_setzero_si256();
++- holderi.int_vec = holder1 = _mm256_setzero_si256();
+++ xmm5.int_vec = xmmfive = _mm256_setzero_si256();
+++ xmm4.int_vec = xmmfour = _mm256_setzero_si256();
+++ holderf.int_vec = holder0 = _mm256_setzero_si256();
+++ holderi.int_vec = holder1 = _mm256_setzero_si256();
++
++- int bound = num_bytes >> 6;
++- int i = 0;
+++ int bound = num_bytes >> 6;
+++ int i = 0;
++
++- xmm8 = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
++- xmm9 = _mm256_setzero_si256(); //=xmm8
++- xmm10 = _mm256_set1_epi32(8);
++- xmm3 = _mm256_setzero_ps();
+++ xmm8 = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
+++ xmm9 = _mm256_setzero_si256(); //=xmm8
+++ xmm10 = _mm256_set1_epi32(8);
+++ xmm3 = _mm256_setzero_ps();
++
++- __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
++- for(; i < bound; ++i) {
++- xmm1 = _mm256_loadu_ps((float*)src0);
++- xmm2 = _mm256_loadu_ps((float*)&src0[4]);
+++ __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
+++ for (; i < bound; ++i) {
+++ xmm1 = _mm256_loadu_ps((float*)src0);
+++ xmm2 = _mm256_loadu_ps((float*)&src0[4]);
++
++- src0 += 8;
+++ src0 += 8;
++
++- xmm1 = _mm256_mul_ps(xmm1, xmm1);
++- xmm2 = _mm256_mul_ps(xmm2, xmm2);
+++ xmm1 = _mm256_mul_ps(xmm1, xmm1);
+++ xmm2 = _mm256_mul_ps(xmm2, xmm2);
++
++- xmm1 = _mm256_hadd_ps(xmm1, xmm2);
++- xmm1 = _mm256_permutevar8x32_ps(xmm1, idx);
+++ xmm1 = _mm256_hadd_ps(xmm1, xmm2);
+++ xmm1 = _mm256_permutevar8x32_ps(xmm1, idx);
++
++- xmm3 = _mm256_max_ps(xmm1, xmm3);
+++ xmm3 = _mm256_max_ps(xmm1, xmm3);
++
++- xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
++- xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
+++ xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
+++ xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++
++- xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
++- xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
+++ xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
+++ xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
++
++- xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++ xmm9 = _mm256_add_epi32(xmm11, xmm12);
++
++- xmm8 = _mm256_add_epi32(xmm8, xmm10);
++- }
++- xmm10 = _mm256_set1_epi32(4);
++- if (num_bytes >> 5 & 1) {
++- xmm1 = _mm256_loadu_ps((float*)src0);
+++ xmm8 = _mm256_add_epi32(xmm8, xmm10);
+++ }
+++ xmm10 = _mm256_set1_epi32(4);
+++ if (num_bytes >> 5 & 1) {
+++ xmm1 = _mm256_loadu_ps((float*)src0);
++
++- src0 += 4;
+++ src0 += 4;
++
++- xmm1 = _mm256_mul_ps(xmm1, xmm1);
+++ xmm1 = _mm256_mul_ps(xmm1, xmm1);
++
++- xmm1 = _mm256_hadd_ps(xmm1, xmm1);
++- xmm1 = _mm256_permutevar8x32_ps(xmm1, idx);
+++ xmm1 = _mm256_hadd_ps(xmm1, xmm1);
+++ xmm1 = _mm256_permutevar8x32_ps(xmm1, idx);
++
++- xmm3 = _mm256_max_ps(xmm1, xmm3);
+++ xmm3 = _mm256_max_ps(xmm1, xmm3);
++
++- xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
++- xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
+++ xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
+++ xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++
++- xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
++- xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
+++ xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
+++ xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
++
++- xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++ xmm9 = _mm256_add_epi32(xmm11, xmm12);
++
++- xmm8 = _mm256_add_epi32(xmm8, xmm10);
++- }
+++ xmm8 = _mm256_add_epi32(xmm8, xmm10);
+++ }
++
++- idx = _mm256_set_epi32(1,0,1,0,1,0,1,0);
++- xmm10 = _mm256_set1_epi32(2);
++- if (num_bytes >> 4 & 1) {
++- xmm2 = _mm256_loadu_ps((float*)src0);
+++ idx = _mm256_set_epi32(1, 0, 1, 0, 1, 0, 1, 0);
+++ xmm10 = _mm256_set1_epi32(2);
+++ if (num_bytes >> 4 & 1) {
+++ xmm2 = _mm256_loadu_ps((float*)src0);
++
++- xmm1 = _mm256_permutevar8x32_ps(bit256_p(&xmm8)->float_vec, idx);
++- xmm8 = bit256_p(&xmm1)->int_vec;
+++ xmm1 = _mm256_permutevar8x32_ps(bit256_p(&xmm8)->float_vec, idx);
+++ xmm8 = bit256_p(&xmm1)->int_vec;
++
++- xmm2 = _mm256_mul_ps(xmm2, xmm2);
+++ xmm2 = _mm256_mul_ps(xmm2, xmm2);
++
++- src0 += 2;
+++ src0 += 2;
++
++- xmm1 = _mm256_hadd_ps(xmm2, xmm2);
+++ xmm1 = _mm256_hadd_ps(xmm2, xmm2);
++
++- xmm3 = _mm256_max_ps(xmm1, xmm3);
+++ xmm3 = _mm256_max_ps(xmm1, xmm3);
++
++- xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
++- xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
+++ xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
+++ xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++
++- xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
++- xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
+++ xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
+++ xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
++
++- xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++ xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++
+++ xmm8 = _mm256_add_epi32(xmm8, xmm10);
+++ }
++
++- xmm8 = _mm256_add_epi32(xmm8, xmm10);
++- }
++-
++- _mm256_storeu_ps((float*)&(holderf.f), xmm3);
++- _mm256_storeu_si256(&(holderi.int_vec), xmm9);
++-
++- target[0] = holderi.i[0];
++- sq_dist = holderf.f[0];
++- target[0] = (holderf.f[1] > sq_dist) ? holderi.i[1] : target[0];
++- sq_dist = (holderf.f[1] > sq_dist) ? holderf.f[1] : sq_dist;
++- target[0] = (holderf.f[2] > sq_dist) ? holderi.i[2] : target[0];
++- sq_dist = (holderf.f[2] > sq_dist) ? holderf.f[2] : sq_dist;
++- target[0] = (holderf.f[3] > sq_dist) ? holderi.i[3] : target[0];
++- sq_dist = (holderf.f[3] > sq_dist) ? holderf.f[3] : sq_dist;
++- target[0] = (holderf.f[4] > sq_dist) ? holderi.i[4] : target[0];
++- sq_dist = (holderf.f[4] > sq_dist) ? holderf.f[4] : sq_dist;
++- target[0] = (holderf.f[5] > sq_dist) ? holderi.i[5] : target[0];
++- sq_dist = (holderf.f[5] > sq_dist) ? holderf.f[5] : sq_dist;
++- target[0] = (holderf.f[6] > sq_dist) ? holderi.i[6] : target[0];
++- sq_dist = (holderf.f[6] > sq_dist) ? holderf.f[6] : sq_dist;
++- target[0] = (holderf.f[7] > sq_dist) ? holderi.i[7] : target[0];
++- sq_dist = (holderf.f[7] > sq_dist) ? holderf.f[7] : sq_dist;
+++ _mm256_storeu_ps((float*)&(holderf.f), xmm3);
+++ _mm256_storeu_si256(&(holderi.int_vec), xmm9);
++
+++ target[0] = holderi.i[0];
+++ sq_dist = holderf.f[0];
+++ target[0] = (holderf.f[1] > sq_dist) ? holderi.i[1] : target[0];
+++ sq_dist = (holderf.f[1] > sq_dist) ? holderf.f[1] : sq_dist;
+++ target[0] = (holderf.f[2] > sq_dist) ? holderi.i[2] : target[0];
+++ sq_dist = (holderf.f[2] > sq_dist) ? holderf.f[2] : sq_dist;
+++ target[0] = (holderf.f[3] > sq_dist) ? holderi.i[3] : target[0];
+++ sq_dist = (holderf.f[3] > sq_dist) ? holderf.f[3] : sq_dist;
+++ target[0] = (holderf.f[4] > sq_dist) ? holderi.i[4] : target[0];
+++ sq_dist = (holderf.f[4] > sq_dist) ? holderf.f[4] : sq_dist;
+++ target[0] = (holderf.f[5] > sq_dist) ? holderi.i[5] : target[0];
+++ sq_dist = (holderf.f[5] > sq_dist) ? holderf.f[5] : sq_dist;
+++ target[0] = (holderf.f[6] > sq_dist) ? holderi.i[6] : target[0];
+++ sq_dist = (holderf.f[6] > sq_dist) ? holderf.f[6] : sq_dist;
+++ target[0] = (holderf.f[7] > sq_dist) ? holderi.i[7] : target[0];
+++ sq_dist = (holderf.f[7] > sq_dist) ? holderf.f[7] : sq_dist;
++ }
++
++ #endif /*LV_HAVE_AVX2*/
++diff --git a/kernels/volk/volk_32fc_index_max_32u.h b/kernels/volk/volk_32fc_index_max_32u.h
++index 67a3faa..7756fc6 100644
++--- a/kernels/volk/volk_32fc_index_max_32u.h
+++++ b/kernels/volk/volk_32fc_index_max_32u.h
++@@ -70,309 +70,314 @@
++ #ifndef INCLUDED_volk_32fc_index_max_32u_a_H
++ #define INCLUDED_volk_32fc_index_max_32u_a_H
++
+++#include <inttypes.h>
+++#include <stdio.h>
++ #include <volk/volk_common.h>
++-#include<inttypes.h>
++-#include<stdio.h>
++-#include<volk/volk_complex.h>
+++#include <volk/volk_complex.h>
++
++ #ifdef LV_HAVE_AVX2
++-#include<immintrin.h>
+++#include <immintrin.h>
++
++ static inline void
++-volk_32fc_index_max_32u_a_avx2(uint32_t* target, lv_32fc_t* src0,
++- uint32_t num_points)
+++volk_32fc_index_max_32u_a_avx2(uint32_t* target, lv_32fc_t* src0, uint32_t num_points)
++ {
++- const uint32_t num_bytes = num_points*8;
+++ const uint32_t num_bytes = num_points * 8;
++
++- union bit256 holderf;
++- union bit256 holderi;
++- float sq_dist = 0.0;
+++ union bit256 holderf;
+++ union bit256 holderi;
+++ float sq_dist = 0.0;
++
++- union bit256 xmm5, xmm4;
++- __m256 xmm1, xmm2, xmm3;
++- __m256i xmm8, xmm11, xmm12, xmmfive, xmmfour, xmm9, holder0, holder1, xmm10;
+++ union bit256 xmm5, xmm4;
+++ __m256 xmm1, xmm2, xmm3;
+++ __m256i xmm8, xmm11, xmm12, xmmfive, xmmfour, xmm9, holder0, holder1, xmm10;
++
++- xmm5.int_vec = xmmfive = _mm256_setzero_si256();
++- xmm4.int_vec = xmmfour = _mm256_setzero_si256();
++- holderf.int_vec = holder0 = _mm256_setzero_si256();
++- holderi.int_vec = holder1 = _mm256_setzero_si256();
+++ xmm5.int_vec = xmmfive = _mm256_setzero_si256();
+++ xmm4.int_vec = xmmfour = _mm256_setzero_si256();
+++ holderf.int_vec = holder0 = _mm256_setzero_si256();
+++ holderi.int_vec = holder1 = _mm256_setzero_si256();
++
++- int bound = num_bytes >> 6;
++- int i = 0;
+++ int bound = num_bytes >> 6;
+++ int i = 0;
++
++- xmm8 = _mm256_set_epi32(7,6,5,4,3, 2, 1, 0);
++- xmm9 = _mm256_setzero_si256();
++- xmm10 = _mm256_set1_epi32(8);
++- xmm3 = _mm256_setzero_ps();
++- __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
+++ xmm8 = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
+++ xmm9 = _mm256_setzero_si256();
+++ xmm10 = _mm256_set1_epi32(8);
+++ xmm3 = _mm256_setzero_ps();
+++ __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
++
++- for(; i < bound; ++i) {
++- xmm1 = _mm256_load_ps((float*)src0);
++- xmm2 = _mm256_load_ps((float*)&src0[4]);
+++ for (; i < bound; ++i) {
+++ xmm1 = _mm256_load_ps((float*)src0);
+++ xmm2 = _mm256_load_ps((float*)&src0[4]);
++
++- src0 += 8;
+++ src0 += 8;
++
++- xmm1 = _mm256_mul_ps(xmm1, xmm1);
++- xmm2 = _mm256_mul_ps(xmm2, xmm2);
+++ xmm1 = _mm256_mul_ps(xmm1, xmm1);
+++ xmm2 = _mm256_mul_ps(xmm2, xmm2);
++
++- xmm1 = _mm256_hadd_ps(xmm1, xmm2);
++- xmm1 = _mm256_permutevar8x32_ps(xmm1, idx);
+++ xmm1 = _mm256_hadd_ps(xmm1, xmm2);
+++ xmm1 = _mm256_permutevar8x32_ps(xmm1, idx);
++
++- xmm3 = _mm256_max_ps(xmm1, xmm3);
+++ xmm3 = _mm256_max_ps(xmm1, xmm3);
++
++- xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
++- xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
+++ xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
+++ xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++
++- xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
++- xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
+++ xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
+++ xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
++
++- xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++ xmm9 = _mm256_add_epi32(xmm11, xmm12);
++
++- xmm8 = _mm256_add_epi32(xmm8, xmm10);
++- }
++-
++- xmm10 = _mm256_set1_epi32(4);
++- if (num_bytes >> 5 & 1) {
++- xmm1 = _mm256_load_ps((float*)src0);
++-
++- xmm1 = _mm256_mul_ps(xmm1, xmm1);
+++ xmm8 = _mm256_add_epi32(xmm8, xmm10);
+++ }
++
++- src0 += 4;
+++ xmm10 = _mm256_set1_epi32(4);
+++ if (num_bytes >> 4 & 1) {
+++ xmm1 = _mm256_load_ps((float*)src0);
++
++- xmm1 = _mm256_hadd_ps(xmm1, xmm1);
+++ xmm1 = _mm256_mul_ps(xmm1, xmm1);
++
++- xmm3 = _mm256_max_ps(xmm1, xmm3);
+++ src0 += 4;
++
++- xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
++- xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
+++ xmm1 = _mm256_hadd_ps(xmm1, xmm1);
++
++- xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
++- xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
+++ xmm3 = _mm256_max_ps(xmm1, xmm3);
++
++- xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++ xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
+++ xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++
++- xmm8 = _mm256_add_epi32(xmm8, xmm10);
++- }
+++ xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
+++ xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
++
++- idx = _mm256_set_epi32(1,0,1,0,1,0,1,0);
++- xmm10 = _mm256_set1_epi32(2);
++- if (num_bytes >> 4 & 1) {
++- xmm2 = _mm256_load_ps((float*)src0);
+++ xmm9 = _mm256_add_epi32(xmm11, xmm12);
++
++- xmm1 = _mm256_permutevar8x32_ps(bit256_p(&xmm8)->float_vec, idx);
++- xmm8 = bit256_p(&xmm1)->int_vec;
+++ xmm8 = _mm256_add_epi32(xmm8, xmm10);
+++ }
++
++- xmm2 = _mm256_mul_ps(xmm2, xmm2);
+++ idx = _mm256_set_epi32(1, 0, 1, 0, 1, 0, 1, 0);
+++ xmm10 = _mm256_set1_epi32(2);
+++ if (num_bytes >> 4 & 1) {
+++ xmm2 = _mm256_load_ps((float*)src0);
++
++- src0 += 2;
+++ xmm1 = _mm256_permutevar8x32_ps(bit256_p(&xmm8)->float_vec, idx);
+++ xmm8 = bit256_p(&xmm1)->int_vec;
++
++- xmm1 = _mm256_hadd_ps(xmm2, xmm2);
+++ xmm2 = _mm256_mul_ps(xmm2, xmm2);
++
++- xmm3 = _mm256_max_ps(xmm1, xmm3);
+++ src0 += 2;
++
++- xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
++- xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
+++ xmm1 = _mm256_hadd_ps(xmm2, xmm2);
++
++- xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
++- xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
+++ xmm3 = _mm256_max_ps(xmm1, xmm3);
++
++- xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++ xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
+++ xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++
++- xmm8 = _mm256_add_epi32(xmm8, xmm10);
++- }
+++ xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
+++ xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
++
++- _mm256_store_ps((float*)&(holderf.f), xmm3);
++- _mm256_store_si256(&(holderi.int_vec), xmm9);
+++ xmm9 = _mm256_add_epi32(xmm11, xmm12);
++
++- target[0] = holderi.i[0];
++- sq_dist = holderf.f[0];
++- target[0] = (holderf.f[1] > sq_dist) ? holderi.i[1] : target[0];
++- sq_dist = (holderf.f[1] > sq_dist) ? holderf.f[1] : sq_dist;
++- target[0] = (holderf.f[2] > sq_dist) ? holderi.i[2] : target[0];
++- sq_dist = (holderf.f[2] > sq_dist) ? holderf.f[2] : sq_dist;
++- target[0] = (holderf.f[3] > sq_dist) ? holderi.i[3] : target[0];
++- sq_dist = (holderf.f[3] > sq_dist) ? holderf.f[3] : sq_dist;
++- target[0] = (holderf.f[4] > sq_dist) ? holderi.i[4] : target[0];
++- sq_dist = (holderf.f[4] > sq_dist) ? holderf.f[4] : sq_dist;
++- target[0] = (holderf.f[5] > sq_dist) ? holderi.i[5] : target[0];
++- sq_dist = (holderf.f[5] > sq_dist) ? holderf.f[5] : sq_dist;
++- target[0] = (holderf.f[6] > sq_dist) ? holderi.i[6] : target[0];
++- sq_dist = (holderf.f[6] > sq_dist) ? holderf.f[6] : sq_dist;
++- target[0] = (holderf.f[7] > sq_dist) ? holderi.i[7] : target[0];
++- sq_dist = (holderf.f[7] > sq_dist) ? holderf.f[7] : sq_dist;
+++ xmm8 = _mm256_add_epi32(xmm8, xmm10);
+++ }
++
+++ _mm256_store_ps((float*)&(holderf.f), xmm3);
+++ _mm256_store_si256(&(holderi.int_vec), xmm9);
+++
+++ target[0] = holderi.i[0];
+++ sq_dist = holderf.f[0];
+++ target[0] = (holderf.f[1] > sq_dist) ? holderi.i[1] : target[0];
+++ sq_dist = (holderf.f[1] > sq_dist) ? holderf.f[1] : sq_dist;
+++ target[0] = (holderf.f[2] > sq_dist) ? holderi.i[2] : target[0];
+++ sq_dist = (holderf.f[2] > sq_dist) ? holderf.f[2] : sq_dist;
+++ target[0] = (holderf.f[3] > sq_dist) ? holderi.i[3] : target[0];
+++ sq_dist = (holderf.f[3] > sq_dist) ? holderf.f[3] : sq_dist;
+++ target[0] = (holderf.f[4] > sq_dist) ? holderi.i[4] : target[0];
+++ sq_dist = (holderf.f[4] > sq_dist) ? holderf.f[4] : sq_dist;
+++ target[0] = (holderf.f[5] > sq_dist) ? holderi.i[5] : target[0];
+++ sq_dist = (holderf.f[5] > sq_dist) ? holderf.f[5] : sq_dist;
+++ target[0] = (holderf.f[6] > sq_dist) ? holderi.i[6] : target[0];
+++ sq_dist = (holderf.f[6] > sq_dist) ? holderf.f[6] : sq_dist;
+++ target[0] = (holderf.f[7] > sq_dist) ? holderi.i[7] : target[0];
+++ sq_dist = (holderf.f[7] > sq_dist) ? holderf.f[7] : sq_dist;
++ }
++
++ #endif /*LV_HAVE_AVX2*/
++
++ #ifdef LV_HAVE_SSE3
++-#include<xmmintrin.h>
++-#include<pmmintrin.h>
+++#include <pmmintrin.h>
+++#include <xmmintrin.h>
++
++ static inline void
++-volk_32fc_index_max_32u_a_sse3(uint32_t* target, lv_32fc_t* src0,
++- uint32_t num_points)
+++volk_32fc_index_max_32u_a_sse3(uint32_t* target, lv_32fc_t* src0, uint32_t num_points)
++ {
++- const uint32_t num_bytes = num_points*8;
++-
++- union bit128 holderf;
++- union bit128 holderi;
++- float sq_dist = 0.0;
++-
++- union bit128 xmm5, xmm4;
++- __m128 xmm1, xmm2, xmm3;
++- __m128i xmm8, xmm11, xmm12, xmmfive, xmmfour, xmm9, holder0, holder1, xmm10;
+++ const uint32_t num_bytes = num_points * 8;
++
++- xmm5.int_vec = xmmfive = _mm_setzero_si128();
++- xmm4.int_vec = xmmfour = _mm_setzero_si128();
++- holderf.int_vec = holder0 = _mm_setzero_si128();
++- holderi.int_vec = holder1 = _mm_setzero_si128();
+++ union bit128 holderf;
+++ union bit128 holderi;
+++ float sq_dist = 0.0;
++
++- int bound = num_bytes >> 5;
++- int i = 0;
+++ union bit128 xmm5, xmm4;
+++ __m128 xmm1, xmm2, xmm3;
+++ __m128i xmm8, xmm11, xmm12, xmmfive, xmmfour, xmm9, holder0, holder1, xmm10;
++
++- xmm8 = _mm_set_epi32(3, 2, 1, 0);//remember the crazy reverse order!
++- xmm9 = _mm_setzero_si128();
++- xmm10 = _mm_set_epi32(4, 4, 4, 4);
++- xmm3 = _mm_setzero_ps();
+++ xmm5.int_vec = xmmfive = _mm_setzero_si128();
+++ xmm4.int_vec = xmmfour = _mm_setzero_si128();
+++ holderf.int_vec = holder0 = _mm_setzero_si128();
+++ holderi.int_vec = holder1 = _mm_setzero_si128();
++
++- //printf("%f, %f, %f, %f\n", ((float*)&xmm10)[0], ((float*)&xmm10)[1], ((float*)&xmm10)[2], ((float*)&xmm10)[3]);
+++ int bound = num_bytes >> 5;
+++ int i = 0;
++
++- for(; i < bound; ++i) {
++- xmm1 = _mm_load_ps((float*)src0);
++- xmm2 = _mm_load_ps((float*)&src0[2]);
+++ xmm8 = _mm_set_epi32(3, 2, 1, 0); // remember the crazy reverse order!
+++ xmm9 = _mm_setzero_si128();
+++ xmm10 = _mm_set_epi32(4, 4, 4, 4);
+++ xmm3 = _mm_setzero_ps();
++
++- src0 += 4;
+++ // printf("%f, %f, %f, %f\n", ((float*)&xmm10)[0], ((float*)&xmm10)[1],
+++ // ((float*)&xmm10)[2], ((float*)&xmm10)[3]);
++
++- xmm1 = _mm_mul_ps(xmm1, xmm1);
++- xmm2 = _mm_mul_ps(xmm2, xmm2);
+++ for (; i < bound; ++i) {
+++ xmm1 = _mm_load_ps((float*)src0);
+++ xmm2 = _mm_load_ps((float*)&src0[2]);
++
++- xmm1 = _mm_hadd_ps(xmm1, xmm2);
+++ src0 += 4;
++
++- xmm3 = _mm_max_ps(xmm1, xmm3);
+++ xmm1 = _mm_mul_ps(xmm1, xmm1);
+++ xmm2 = _mm_mul_ps(xmm2, xmm2);
++
++- xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);
++- xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);
+++ xmm1 = _mm_hadd_ps(xmm1, xmm2);
++
++- xmm11 = _mm_and_si128(xmm8, xmm5.int_vec);
++- xmm12 = _mm_and_si128(xmm9, xmm4.int_vec);
+++ xmm3 = _mm_max_ps(xmm1, xmm3);
++
++- xmm9 = _mm_add_epi32(xmm11, xmm12);
+++ xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);
+++ xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);
++
++- xmm8 = _mm_add_epi32(xmm8, xmm10);
+++ xmm11 = _mm_and_si128(xmm8, xmm5.int_vec);
+++ xmm12 = _mm_and_si128(xmm9, xmm4.int_vec);
++
++- //printf("%f, %f, %f, %f\n", ((float*)&xmm3)[0], ((float*)&xmm3)[1], ((float*)&xmm3)[2], ((float*)&xmm3)[3]);
++- //printf("%u, %u, %u, %u\n", ((uint32_t*)&xmm10)[0], ((uint32_t*)&xmm10)[1], ((uint32_t*)&xmm10)[2], ((uint32_t*)&xmm10)[3]);
++- }
+++ xmm9 = _mm_add_epi32(xmm11, xmm12);
++
+++ xmm8 = _mm_add_epi32(xmm8, xmm10);
++
++- if (num_bytes >> 4 & 1) {
++- xmm2 = _mm_load_ps((float*)src0);
++-
++- xmm1 = _mm_movelh_ps(bit128_p(&xmm8)->float_vec, bit128_p(&xmm8)->float_vec);
++- xmm8 = bit128_p(&xmm1)->int_vec;
++-
++- xmm2 = _mm_mul_ps(xmm2, xmm2);
++-
++- src0 += 2;
++-
++- xmm1 = _mm_hadd_ps(xmm2, xmm2);
+++ // printf("%f, %f, %f, %f\n", ((float*)&xmm3)[0], ((float*)&xmm3)[1],
+++ // ((float*)&xmm3)[2], ((float*)&xmm3)[3]); printf("%u, %u, %u, %u\n",
+++ // ((uint32_t*)&xmm10)[0], ((uint32_t*)&xmm10)[1], ((uint32_t*)&xmm10)[2],
+++ // ((uint32_t*)&xmm10)[3]);
+++ }
++
++- xmm3 = _mm_max_ps(xmm1, xmm3);
++
++- xmm10 = _mm_set_epi32(2, 2, 2, 2);//load1_ps((float*)&init[2]);
+++ if (num_bytes >> 4 & 1) {
+++ xmm2 = _mm_load_ps((float*)src0);
++
++- xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);
++- xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);
+++ xmm1 = _mm_movelh_ps(bit128_p(&xmm8)->float_vec, bit128_p(&xmm8)->float_vec);
+++ xmm8 = bit128_p(&xmm1)->int_vec;
++
++- xmm11 = _mm_and_si128(xmm8, xmm5.int_vec);
++- xmm12 = _mm_and_si128(xmm9, xmm4.int_vec);
+++ xmm2 = _mm_mul_ps(xmm2, xmm2);
++
++- xmm9 = _mm_add_epi32(xmm11, xmm12);
+++ src0 += 2;
++
++- xmm8 = _mm_add_epi32(xmm8, xmm10);
++- //printf("egads%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1], ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);
++- }
+++ xmm1 = _mm_hadd_ps(xmm2, xmm2);
++
++- if (num_bytes >> 3 & 1) {
++- //printf("%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1], ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);
+++ xmm3 = _mm_max_ps(xmm1, xmm3);
++
++- sq_dist = lv_creal(src0[0]) * lv_creal(src0[0]) + lv_cimag(src0[0]) * lv_cimag(src0[0]);
+++ xmm10 = _mm_set_epi32(2, 2, 2, 2); // load1_ps((float*)&init[2]);
++
++- xmm2 = _mm_load1_ps(&sq_dist);
+++ xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);
+++ xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);
++
++- xmm1 = xmm3;
+++ xmm11 = _mm_and_si128(xmm8, xmm5.int_vec);
+++ xmm12 = _mm_and_si128(xmm9, xmm4.int_vec);
++
++- xmm3 = _mm_max_ss(xmm3, xmm2);
+++ xmm9 = _mm_add_epi32(xmm11, xmm12);
++
++- xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);
++- xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);
+++ xmm8 = _mm_add_epi32(xmm8, xmm10);
+++ // printf("egads%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1],
+++ // ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);
+++ }
++
++- xmm8 = _mm_shuffle_epi32(xmm8, 0x00);
+++ if (num_bytes >> 3 & 1) {
+++ // printf("%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1],
+++ // ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);
++
++- xmm11 = _mm_and_si128(xmm8, xmm4.int_vec);
++- xmm12 = _mm_and_si128(xmm9, xmm5.int_vec);
+++ sq_dist =
+++ lv_creal(src0[0]) * lv_creal(src0[0]) + lv_cimag(src0[0]) * lv_cimag(src0[0]);
++
++- xmm9 = _mm_add_epi32(xmm11, xmm12);
++- }
+++ xmm2 = _mm_load1_ps(&sq_dist);
++
++- //printf("%f, %f, %f, %f\n", ((float*)&xmm3)[0], ((float*)&xmm3)[1], ((float*)&xmm3)[2], ((float*)&xmm3)[3]);
++- //printf("%u, %u, %u, %u\n", ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1], ((uint32_t*)&xmm9)[2], ((uint32_t*)&xmm9)[3]);
+++ xmm1 = xmm3;
++
++- _mm_store_ps((float*)&(holderf.f), xmm3);
++- _mm_store_si128(&(holderi.int_vec), xmm9);
+++ xmm3 = _mm_max_ss(xmm3, xmm2);
++
++- target[0] = holderi.i[0];
++- sq_dist = holderf.f[0];
++- target[0] = (holderf.f[1] > sq_dist) ? holderi.i[1] : target[0];
++- sq_dist = (holderf.f[1] > sq_dist) ? holderf.f[1] : sq_dist;
++- target[0] = (holderf.f[2] > sq_dist) ? holderi.i[2] : target[0];
++- sq_dist = (holderf.f[2] > sq_dist) ? holderf.f[2] : sq_dist;
++- target[0] = (holderf.f[3] > sq_dist) ? holderi.i[3] : target[0];
++- sq_dist = (holderf.f[3] > sq_dist) ? holderf.f[3] : sq_dist;
+++ xmm4.float_vec = _mm_cmplt_ps(xmm1, xmm3);
+++ xmm5.float_vec = _mm_cmpeq_ps(xmm1, xmm3);
++
++- /*
++- float placeholder = 0.0;
++- uint32_t temp0, temp1;
++- uint32_t g0 = (((float*)&xmm3)[0] > ((float*)&xmm3)[1]);
++- uint32_t l0 = g0 ^ 1;
+++ xmm8 = _mm_shuffle_epi32(xmm8, 0x00);
++
++- uint32_t g1 = (((float*)&xmm3)[1] > ((float*)&xmm3)[2]);
++- uint32_t l1 = g1 ^ 1;
+++ xmm11 = _mm_and_si128(xmm8, xmm4.int_vec);
+++ xmm12 = _mm_and_si128(xmm9, xmm5.int_vec);
++
++- temp0 = g0 * ((uint32_t*)&xmm9)[0] + l0 * ((uint32_t*)&xmm9)[1];
++- temp1 = g0 * ((uint32_t*)&xmm9)[2] + l0 * ((uint32_t*)&xmm9)[3];
++- sq_dist = g0 * ((float*)&xmm3)[0] + l0 * ((float*)&xmm3)[1];
++- placeholder = g0 * ((float*)&xmm3)[2] + l0 * ((float*)&xmm3)[3];
+++ xmm9 = _mm_add_epi32(xmm11, xmm12);
+++ }
++
++- g0 = (sq_dist > placeholder);
++- l0 = g0 ^ 1;
++- target[0] = g0 * temp0 + l0 * temp1;
++- */
+++ // printf("%f, %f, %f, %f\n", ((float*)&xmm3)[0], ((float*)&xmm3)[1],
+++ // ((float*)&xmm3)[2], ((float*)&xmm3)[3]); printf("%u, %u, %u, %u\n",
+++ // ((uint32_t*)&xmm9)[0], ((uint32_t*)&xmm9)[1], ((uint32_t*)&xmm9)[2],
+++ // ((uint32_t*)&xmm9)[3]);
+++
+++ _mm_store_ps((float*)&(holderf.f), xmm3);
+++ _mm_store_si128(&(holderi.int_vec), xmm9);
+++
+++ target[0] = holderi.i[0];
+++ sq_dist = holderf.f[0];
+++ target[0] = (holderf.f[1] > sq_dist) ? holderi.i[1] : target[0];
+++ sq_dist = (holderf.f[1] > sq_dist) ? holderf.f[1] : sq_dist;
+++ target[0] = (holderf.f[2] > sq_dist) ? holderi.i[2] : target[0];
+++ sq_dist = (holderf.f[2] > sq_dist) ? holderf.f[2] : sq_dist;
+++ target[0] = (holderf.f[3] > sq_dist) ? holderi.i[3] : target[0];
+++ sq_dist = (holderf.f[3] > sq_dist) ? holderf.f[3] : sq_dist;
+++
+++ /*
+++ float placeholder = 0.0;
+++ uint32_t temp0, temp1;
+++ uint32_t g0 = (((float*)&xmm3)[0] > ((float*)&xmm3)[1]);
+++ uint32_t l0 = g0 ^ 1;
+++
+++ uint32_t g1 = (((float*)&xmm3)[1] > ((float*)&xmm3)[2]);
+++ uint32_t l1 = g1 ^ 1;
+++
+++ temp0 = g0 * ((uint32_t*)&xmm9)[0] + l0 * ((uint32_t*)&xmm9)[1];
+++ temp1 = g0 * ((uint32_t*)&xmm9)[2] + l0 * ((uint32_t*)&xmm9)[3];
+++ sq_dist = g0 * ((float*)&xmm3)[0] + l0 * ((float*)&xmm3)[1];
+++ placeholder = g0 * ((float*)&xmm3)[2] + l0 * ((float*)&xmm3)[3];
+++
+++ g0 = (sq_dist > placeholder);
+++ l0 = g0 ^ 1;
+++ target[0] = g0 * temp0 + l0 * temp1;
+++ */
++ }
++
++ #endif /*LV_HAVE_SSE3*/
++
++ #ifdef LV_HAVE_GENERIC
++ static inline void
++- volk_32fc_index_max_32u_generic(uint32_t* target, lv_32fc_t* src0,
++- uint32_t num_points)
+++volk_32fc_index_max_32u_generic(uint32_t* target, lv_32fc_t* src0, uint32_t num_points)
++ {
++- const uint32_t num_bytes = num_points*8;
+++ const uint32_t num_bytes = num_points * 8;
++
++- float sq_dist = 0.0;
++- float max = 0.0;
++- uint32_t index = 0;
+++ float sq_dist = 0.0;
+++ float max = 0.0;
+++ uint32_t index = 0;
++
++- uint32_t i = 0;
+++ uint32_t i = 0;
++
++- for(; i < num_bytes >> 3; ++i) {
++- sq_dist = lv_creal(src0[i]) * lv_creal(src0[i]) + lv_cimag(src0[i]) * lv_cimag(src0[i]);
+++ for (; i<num_bytes>> 3; ++i) {
+++ sq_dist =
+++ lv_creal(src0[i]) * lv_creal(src0[i]) + lv_cimag(src0[i]) * lv_cimag(src0[i]);
++
++- index = sq_dist > max ? i : index;
++- max = sq_dist > max ? sq_dist : max;
++- }
++- target[0] = index;
+++ index = sq_dist > max ? i : index;
+++ max = sq_dist > max ? sq_dist : max;
+++ }
+++ target[0] = index;
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -384,137 +389,135 @@ static inline void
++ #ifndef INCLUDED_volk_32fc_index_max_32u_u_H
++ #define INCLUDED_volk_32fc_index_max_32u_u_H
++
+++#include <inttypes.h>
+++#include <stdio.h>
++ #include <volk/volk_common.h>
++-#include<inttypes.h>
++-#include<stdio.h>
++-#include<volk/volk_complex.h>
+++#include <volk/volk_complex.h>
++
++ #ifdef LV_HAVE_AVX2
++-#include<immintrin.h>
+++#include <immintrin.h>
++
++ static inline void
++-volk_32fc_index_max_32u_u_avx2(uint32_t* target, lv_32fc_t* src0,
++- uint32_t num_points)
+++volk_32fc_index_max_32u_u_avx2(uint32_t* target, lv_32fc_t* src0, uint32_t num_points)
++ {
++- const uint32_t num_bytes = num_points*8;
++-
++- union bit256 holderf;
++- union bit256 holderi;
++- float sq_dist = 0.0;
+++ const uint32_t num_bytes = num_points * 8;
++
++- union bit256 xmm5, xmm4;
++- __m256 xmm1, xmm2, xmm3;
++- __m256i xmm8, xmm11, xmm12, xmmfive, xmmfour, xmm9, holder0, holder1, xmm10;
+++ union bit256 holderf;
+++ union bit256 holderi;
+++ float sq_dist = 0.0;
++
++- xmm5.int_vec = xmmfive = _mm256_setzero_si256();
++- xmm4.int_vec = xmmfour = _mm256_setzero_si256();
++- holderf.int_vec = holder0 = _mm256_setzero_si256();
++- holderi.int_vec = holder1 = _mm256_setzero_si256();
+++ union bit256 xmm5, xmm4;
+++ __m256 xmm1, xmm2, xmm3;
+++ __m256i xmm8, xmm11, xmm12, xmmfive, xmmfour, xmm9, holder0, holder1, xmm10;
++
++- int bound = num_bytes >> 6;
++- int i = 0;
+++ xmm5.int_vec = xmmfive = _mm256_setzero_si256();
+++ xmm4.int_vec = xmmfour = _mm256_setzero_si256();
+++ holderf.int_vec = holder0 = _mm256_setzero_si256();
+++ holderi.int_vec = holder1 = _mm256_setzero_si256();
++
++- xmm8 = _mm256_set_epi32(7,6,5,4,3, 2, 1, 0);
++- xmm9 = _mm256_setzero_si256();
++- xmm10 = _mm256_set1_epi32(8);
++- xmm3 = _mm256_setzero_ps();
++- __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
+++ int bound = num_bytes >> 6;
+++ int i = 0;
++
++- for(; i < bound; ++i) {
++- xmm1 = _mm256_loadu_ps((float*)src0);
++- xmm2 = _mm256_loadu_ps((float*)&src0[4]);
+++ xmm8 = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
+++ xmm9 = _mm256_setzero_si256();
+++ xmm10 = _mm256_set1_epi32(8);
+++ xmm3 = _mm256_setzero_ps();
+++ __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
++
++- src0 += 8;
+++ for (; i < bound; ++i) {
+++ xmm1 = _mm256_loadu_ps((float*)src0);
+++ xmm2 = _mm256_loadu_ps((float*)&src0[4]);
++
++- xmm1 = _mm256_mul_ps(xmm1, xmm1);
++- xmm2 = _mm256_mul_ps(xmm2, xmm2);
+++ src0 += 8;
++
++- xmm1 = _mm256_hadd_ps(xmm1, xmm2);
++- xmm1 = _mm256_permutevar8x32_ps(xmm1, idx);
+++ xmm1 = _mm256_mul_ps(xmm1, xmm1);
+++ xmm2 = _mm256_mul_ps(xmm2, xmm2);
++
++- xmm3 = _mm256_max_ps(xmm1, xmm3);
+++ xmm1 = _mm256_hadd_ps(xmm1, xmm2);
+++ xmm1 = _mm256_permutevar8x32_ps(xmm1, idx);
++
++- xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
++- xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
+++ xmm3 = _mm256_max_ps(xmm1, xmm3);
++
++- xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
++- xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
+++ xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
+++ xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++
++- xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++ xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
+++ xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
++
++- xmm8 = _mm256_add_epi32(xmm8, xmm10);
++- }
+++ xmm9 = _mm256_add_epi32(xmm11, xmm12);
++
++- xmm10 = _mm256_set1_epi32(4);
++- if (num_bytes >> 5 & 1) {
++- xmm1 = _mm256_loadu_ps((float*)src0);
++-
++- xmm1 = _mm256_mul_ps(xmm1, xmm1);
+++ xmm8 = _mm256_add_epi32(xmm8, xmm10);
+++ }
++
++- src0 += 4;
+++ xmm10 = _mm256_set1_epi32(4);
+++ if (num_bytes >> 4 & 1) {
+++ xmm1 = _mm256_loadu_ps((float*)src0);
++
++- xmm1 = _mm256_hadd_ps(xmm1, xmm1);
+++ xmm1 = _mm256_mul_ps(xmm1, xmm1);
++
++- xmm3 = _mm256_max_ps(xmm1, xmm3);
+++ src0 += 4;
++
++- xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
++- xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
+++ xmm1 = _mm256_hadd_ps(xmm1, xmm1);
++
++- xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
++- xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
+++ xmm3 = _mm256_max_ps(xmm1, xmm3);
++
++- xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++ xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
+++ xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++
++- xmm8 = _mm256_add_epi32(xmm8, xmm10);
++- }
+++ xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
+++ xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
++
++- idx = _mm256_set_epi32(1,0,1,0,1,0,1,0);
++- xmm10 = _mm256_set1_epi32(2);
++- if (num_bytes >> 4 & 1) {
++- xmm2 = _mm256_loadu_ps((float*)src0);
+++ xmm9 = _mm256_add_epi32(xmm11, xmm12);
++
++- xmm1 = _mm256_permutevar8x32_ps(bit256_p(&xmm8)->float_vec, idx);
++- xmm8 = bit256_p(&xmm1)->int_vec;
+++ xmm8 = _mm256_add_epi32(xmm8, xmm10);
+++ }
++
++- xmm2 = _mm256_mul_ps(xmm2, xmm2);
+++ idx = _mm256_set_epi32(1, 0, 1, 0, 1, 0, 1, 0);
+++ xmm10 = _mm256_set1_epi32(2);
+++ if (num_bytes >> 4 & 1) {
+++ xmm2 = _mm256_loadu_ps((float*)src0);
++
++- src0 += 2;
+++ xmm1 = _mm256_permutevar8x32_ps(bit256_p(&xmm8)->float_vec, idx);
+++ xmm8 = bit256_p(&xmm1)->int_vec;
++
++- xmm1 = _mm256_hadd_ps(xmm2, xmm2);
+++ xmm2 = _mm256_mul_ps(xmm2, xmm2);
++
++- xmm3 = _mm256_max_ps(xmm1, xmm3);
+++ src0 += 2;
++
++- xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
++- xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
+++ xmm1 = _mm256_hadd_ps(xmm2, xmm2);
++
++- xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
++- xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
+++ xmm3 = _mm256_max_ps(xmm1, xmm3);
++
++- xmm9 = _mm256_add_epi32(xmm11, xmm12);
+++ xmm4.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_LT_OS);
+++ xmm5.float_vec = _mm256_cmp_ps(xmm1, xmm3, _CMP_EQ_OQ);
++
++- xmm8 = _mm256_add_epi32(xmm8, xmm10);
++- }
+++ xmm11 = _mm256_and_si256(xmm8, xmm5.int_vec);
+++ xmm12 = _mm256_and_si256(xmm9, xmm4.int_vec);
++
++- _mm256_storeu_ps((float*)&(holderf.f), xmm3);
++- _mm256_storeu_si256(&(holderi.int_vec), xmm9);
+++ xmm9 = _mm256_add_epi32(xmm11, xmm12);
++
++- target[0] = holderi.i[0];
++- sq_dist = holderf.f[0];
++- target[0] = (holderf.f[1] > sq_dist) ? holderi.i[1] : target[0];
++- sq_dist = (holderf.f[1] > sq_dist) ? holderf.f[1] : sq_dist;
++- target[0] = (holderf.f[2] > sq_dist) ? holderi.i[2] : target[0];
++- sq_dist = (holderf.f[2] > sq_dist) ? holderf.f[2] : sq_dist;
++- target[0] = (holderf.f[3] > sq_dist) ? holderi.i[3] : target[0];
++- sq_dist = (holderf.f[3] > sq_dist) ? holderf.f[3] : sq_dist;
++- target[0] = (holderf.f[4] > sq_dist) ? holderi.i[4] : target[0];
++- sq_dist = (holderf.f[4] > sq_dist) ? holderf.f[4] : sq_dist;
++- target[0] = (holderf.f[5] > sq_dist) ? holderi.i[5] : target[0];
++- sq_dist = (holderf.f[5] > sq_dist) ? holderf.f[5] : sq_dist;
++- target[0] = (holderf.f[6] > sq_dist) ? holderi.i[6] : target[0];
++- sq_dist = (holderf.f[6] > sq_dist) ? holderf.f[6] : sq_dist;
++- target[0] = (holderf.f[7] > sq_dist) ? holderi.i[7] : target[0];
++- sq_dist = (holderf.f[7] > sq_dist) ? holderf.f[7] : sq_dist;
+++ xmm8 = _mm256_add_epi32(xmm8, xmm10);
+++ }
++
+++ _mm256_storeu_ps((float*)&(holderf.f), xmm3);
+++ _mm256_storeu_si256(&(holderi.int_vec), xmm9);
+++
+++ target[0] = holderi.i[0];
+++ sq_dist = holderf.f[0];
+++ target[0] = (holderf.f[1] > sq_dist) ? holderi.i[1] : target[0];
+++ sq_dist = (holderf.f[1] > sq_dist) ? holderf.f[1] : sq_dist;
+++ target[0] = (holderf.f[2] > sq_dist) ? holderi.i[2] : target[0];
+++ sq_dist = (holderf.f[2] > sq_dist) ? holderf.f[2] : sq_dist;
+++ target[0] = (holderf.f[3] > sq_dist) ? holderi.i[3] : target[0];
+++ sq_dist = (holderf.f[3] > sq_dist) ? holderf.f[3] : sq_dist;
+++ target[0] = (holderf.f[4] > sq_dist) ? holderi.i[4] : target[0];
+++ sq_dist = (holderf.f[4] > sq_dist) ? holderf.f[4] : sq_dist;
+++ target[0] = (holderf.f[5] > sq_dist) ? holderi.i[5] : target[0];
+++ sq_dist = (holderf.f[5] > sq_dist) ? holderf.f[5] : sq_dist;
+++ target[0] = (holderf.f[6] > sq_dist) ? holderi.i[6] : target[0];
+++ sq_dist = (holderf.f[6] > sq_dist) ? holderf.f[6] : sq_dist;
+++ target[0] = (holderf.f[7] > sq_dist) ? holderi.i[7] : target[0];
+++ sq_dist = (holderf.f[7] > sq_dist) ? holderf.f[7] : sq_dist;
++ }
++
++ #endif /*LV_HAVE_AVX2*/
++@@ -523,29 +526,29 @@ volk_32fc_index_max_32u_u_avx2(uint32_t* target, lv_32fc_t* src0,
++ #include <arm_neon.h>
++ #include <volk/volk_neon_intrinsics.h>
++
++-static inline void volk_32fc_index_max_32u_neon(uint32_t* target, lv_32fc_t* src0, uint32_t num_points)
+++static inline void
+++volk_32fc_index_max_32u_neon(uint32_t* target, lv_32fc_t* src0, uint32_t num_points)
++ {
++ unsigned int number = 0;
++ const uint32_t quarter_points = num_points / 4;
++ const lv_32fc_t* src0Ptr = src0;
++-
++- uint32_t indices[4] = {0, 1, 2, 3};
+++
+++ uint32_t indices[4] = { 0, 1, 2, 3 };
++ const uint32x4_t vec_indices_incr = vdupq_n_u32(4);
++ uint32x4_t vec_indices = vld1q_u32(indices);
++ uint32x4_t vec_max_indices = vec_indices;
++-
++- if(num_points)
++- {
+++
+++ if (num_points) {
++ float max = *src0Ptr;
++ uint32_t index = 0;
++-
+++
++ float32x4_t vec_max = vdupq_n_f32(*src0Ptr);
++-
++- for(;number < quarter_points; number++)
++- {
+++
+++ for (; number < quarter_points; number++) {
++ // Load complex and compute magnitude squared
++- const float32x4_t vec_mag2 = _vmagnitudesquaredq_f32(vld2q_f32((float*)src0Ptr));
++- __VOLK_PREFETCH(src0Ptr+=4);
+++ const float32x4_t vec_mag2 =
+++ _vmagnitudesquaredq_f32(vld2q_f32((float*)src0Ptr));
+++ __VOLK_PREFETCH(src0Ptr += 4);
++ // a > b?
++ const uint32x4_t gt_mask = vcgtq_f32(vec_mag2, vec_max);
++ vec_max = vbslq_f32(gt_mask, vec_mag2, vec_max);
++@@ -556,20 +559,19 @@ static inline void volk_32fc_index_max_32u_neon(uint32_t* target, lv_32fc_t* src
++ float tmp_max[4];
++ vst1q_u32(tmp_max_indices, vec_max_indices);
++ vst1q_f32(tmp_max, vec_max);
++-
+++
++ for (int i = 0; i < 4; i++) {
++ if (tmp_max[i] > max) {
++ max = tmp_max[i];
++ index = tmp_max_indices[i];
++ }
++ }
++-
+++
++ // Deal with the rest
++- for(number = quarter_points * 4;number < num_points; number++)
++- {
+++ for (number = quarter_points * 4; number < num_points; number++) {
++ const float re = lv_creal(*src0Ptr);
++ const float im = lv_cimag(*src0Ptr);
++- if ((re*re+im*im) > max) {
+++ if ((re * re + im * im) > max) {
++ max = *src0Ptr;
++ index = number;
++ }
++diff --git a/kernels/volk/volk_32fc_magnitude_32f.h b/kernels/volk/volk_32fc_magnitude_32f.h
++index 1ba6871..6a0a7d8 100644
++--- a/kernels/volk/volk_32fc_magnitude_32f.h
+++++ b/kernels/volk/volk_32fc_magnitude_32f.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_magnitude_32f(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_magnitude_32f(float* magnitudeVector, const lv_32fc_t* complexVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -72,41 +72,41 @@
++ #define INCLUDED_volk_32fc_magnitude_32f_u_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void
++-volk_32fc_magnitude_32f_u_avx(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_32f_u_avx(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* complexVectorPtr = (float*) complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++-
++- __m256 cplxValue1, cplxValue2, result;
++-
++- for(; number < eighthPoints; number++){
++- cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
++- cplxValue2 = _mm256_loadu_ps(complexVectorPtr + 8);
++- result = _mm256_magnitude_ps(cplxValue1, cplxValue2);
++- _mm256_storeu_ps(magnitudeVectorPtr, result);
++-
++- complexVectorPtr += 16;
++- magnitudeVectorPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- float val1Real = *complexVectorPtr++;
++- float val1Imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
++- }
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++
+++ __m256 cplxValue1, cplxValue2, result;
+++
+++ for (; number < eighthPoints; number++) {
+++ cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
+++ cplxValue2 = _mm256_loadu_ps(complexVectorPtr + 8);
+++ result = _mm256_magnitude_ps(cplxValue1, cplxValue2);
+++ _mm256_storeu_ps(magnitudeVectorPtr, result);
+++
+++ complexVectorPtr += 16;
+++ magnitudeVectorPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ float val1Real = *complexVectorPtr++;
+++ float val1Imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -114,137 +114,137 @@ volk_32fc_magnitude_32f_u_avx(float* magnitudeVector, const lv_32fc_t* complexVe
++ #include <pmmintrin.h>
++ #include <volk/volk_sse3_intrinsics.h>
++
++-static inline void
++-volk_32fc_magnitude_32f_u_sse3(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_32f_u_sse3(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* complexVectorPtr = (float*) complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
++
++- __m128 cplxValue1, cplxValue2, result;
++- for(; number < quarterPoints; number++){
++- cplxValue1 = _mm_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ __m128 cplxValue1, cplxValue2, result;
+++ for (; number < quarterPoints; number++) {
+++ cplxValue1 = _mm_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- cplxValue2 = _mm_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ cplxValue2 = _mm_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- result = _mm_magnitude_ps_sse3(cplxValue1, cplxValue2);
+++ result = _mm_magnitude_ps_sse3(cplxValue1, cplxValue2);
++
++- _mm_storeu_ps(magnitudeVectorPtr, result);
++- magnitudeVectorPtr += 4;
++- }
+++ _mm_storeu_ps(magnitudeVectorPtr, result);
+++ magnitudeVectorPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- float val1Real = *complexVectorPtr++;
++- float val1Imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ float val1Real = *complexVectorPtr++;
+++ float val1Imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
+++ }
++ }
++ #endif /* LV_HAVE_SSE3 */
++
++
++ #ifdef LV_HAVE_SSE
++-#include <xmmintrin.h>
++ #include <volk/volk_sse_intrinsics.h>
+++#include <xmmintrin.h>
++
++-static inline void
++-volk_32fc_magnitude_32f_u_sse(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_32f_u_sse(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* complexVectorPtr = (float*) complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
++
++- __m128 cplxValue1, cplxValue2, result;
+++ __m128 cplxValue1, cplxValue2, result;
++
++- for(; number < quarterPoints; number++){
++- cplxValue1 = _mm_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ for (; number < quarterPoints; number++) {
+++ cplxValue1 = _mm_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- cplxValue2 = _mm_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ cplxValue2 = _mm_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- result = _mm_magnitude_ps(cplxValue1, cplxValue2);
++- _mm_storeu_ps(magnitudeVectorPtr, result);
++- magnitudeVectorPtr += 4;
++- }
+++ result = _mm_magnitude_ps(cplxValue1, cplxValue2);
+++ _mm_storeu_ps(magnitudeVectorPtr, result);
+++ magnitudeVectorPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- float val1Real = *complexVectorPtr++;
++- float val1Imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ float val1Real = *complexVectorPtr++;
+++ float val1Imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_magnitude_32f_generic(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points)
+++static inline void volk_32fc_magnitude_32f_generic(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- const float* complexVectorPtr = (float*)complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++- unsigned int number = 0;
++- for(number = 0; number < num_points; number++){
++- const float real = *complexVectorPtr++;
++- const float imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = sqrtf((real*real) + (imag*imag));
++- }
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++ unsigned int number = 0;
+++ for (number = 0; number < num_points; number++) {
+++ const float real = *complexVectorPtr++;
+++ const float imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = sqrtf((real * real) + (imag * imag));
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++ #endif /* INCLUDED_volk_32fc_magnitude_32f_u_H */
++ #ifndef INCLUDED_volk_32fc_magnitude_32f_a_H
++ #define INCLUDED_volk_32fc_magnitude_32f_a_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void
++-volk_32fc_magnitude_32f_a_avx(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_32f_a_avx(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* complexVectorPtr = (float*) complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++-
++- __m256 cplxValue1, cplxValue2, result;
++- for(; number < eighthPoints; number++){
++- cplxValue1 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- cplxValue2 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- result = _mm256_magnitude_ps(cplxValue1, cplxValue2);
++- _mm256_store_ps(magnitudeVectorPtr, result);
++- magnitudeVectorPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- float val1Real = *complexVectorPtr++;
++- float val1Imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
++- }
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++
+++ __m256 cplxValue1, cplxValue2, result;
+++ for (; number < eighthPoints; number++) {
+++ cplxValue1 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ cplxValue2 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ result = _mm256_magnitude_ps(cplxValue1, cplxValue2);
+++ _mm256_store_ps(magnitudeVectorPtr, result);
+++ magnitudeVectorPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ float val1Real = *complexVectorPtr++;
+++ float val1Imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -252,89 +252,89 @@ volk_32fc_magnitude_32f_a_avx(float* magnitudeVector, const lv_32fc_t* complexVe
++ #include <pmmintrin.h>
++ #include <volk/volk_sse3_intrinsics.h>
++
++-static inline void
++-volk_32fc_magnitude_32f_a_sse3(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_32f_a_sse3(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* complexVectorPtr = (float*) complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++-
++- __m128 cplxValue1, cplxValue2, result;
++- for(; number < quarterPoints; number++){
++- cplxValue1 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- cplxValue2 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- result = _mm_magnitude_ps_sse3(cplxValue1, cplxValue2);
++- _mm_store_ps(magnitudeVectorPtr, result);
++- magnitudeVectorPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- float val1Real = *complexVectorPtr++;
++- float val1Imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++
+++ __m128 cplxValue1, cplxValue2, result;
+++ for (; number < quarterPoints; number++) {
+++ cplxValue1 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ cplxValue2 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ result = _mm_magnitude_ps_sse3(cplxValue1, cplxValue2);
+++ _mm_store_ps(magnitudeVectorPtr, result);
+++ magnitudeVectorPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ float val1Real = *complexVectorPtr++;
+++ float val1Imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
+++ }
++ }
++ #endif /* LV_HAVE_SSE3 */
++
++ #ifdef LV_HAVE_SSE
++-#include <xmmintrin.h>
++ #include <volk/volk_sse_intrinsics.h>
+++#include <xmmintrin.h>
++
++-static inline void
++-volk_32fc_magnitude_32f_a_sse(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_32f_a_sse(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* complexVectorPtr = (float*) complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++-
++- __m128 cplxValue1, cplxValue2, result;
++- for(; number < quarterPoints; number++){
++- cplxValue1 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- cplxValue2 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- result = _mm_magnitude_ps(cplxValue1, cplxValue2);
++- _mm_store_ps(magnitudeVectorPtr, result);
++- magnitudeVectorPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- float val1Real = *complexVectorPtr++;
++- float val1Imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++
+++ __m128 cplxValue1, cplxValue2, result;
+++ for (; number < quarterPoints; number++) {
+++ cplxValue1 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ cplxValue2 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ result = _mm_magnitude_ps(cplxValue1, cplxValue2);
+++ _mm_store_ps(magnitudeVectorPtr, result);
+++ magnitudeVectorPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ float val1Real = *complexVectorPtr++;
+++ float val1Imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = sqrtf((val1Real * val1Real) + (val1Imag * val1Imag));
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_magnitude_32f_a_generic(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_32f_a_generic(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- const float* complexVectorPtr = (float*)complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++- unsigned int number = 0;
++- for(number = 0; number < num_points; number++){
++- const float real = *complexVectorPtr++;
++- const float imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = sqrtf((real*real) + (imag*imag));
++- }
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++ unsigned int number = 0;
+++ for (number = 0; number < num_points; number++) {
+++ const float real = *complexVectorPtr++;
+++ const float imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = sqrtf((real * real) + (imag * imag));
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -342,41 +342,43 @@ volk_32fc_magnitude_32f_a_generic(float* magnitudeVector, const lv_32fc_t* compl
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32fc_magnitude_32f_neon(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_32f_neon(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number;
++- unsigned int quarter_points = num_points / 4;
++- const float* complexVectorPtr = (float*)complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++-
++- float32x4x2_t complex_vec;
++- float32x4_t magnitude_vec;
++- for(number = 0; number < quarter_points; number++){
++- complex_vec = vld2q_f32(complexVectorPtr);
++- complex_vec.val[0] = vmulq_f32(complex_vec.val[0], complex_vec.val[0]);
++- magnitude_vec = vmlaq_f32(complex_vec.val[0], complex_vec.val[1], complex_vec.val[1]);
++- magnitude_vec = vrsqrteq_f32(magnitude_vec);
++- magnitude_vec = vrecpeq_f32( magnitude_vec ); // no plain ol' sqrt
++- vst1q_f32(magnitudeVectorPtr, magnitude_vec);
++-
++- complexVectorPtr += 8;
++- magnitudeVectorPtr += 4;
++- }
++-
++- for(number = quarter_points*4; number < num_points; number++){
++- const float real = *complexVectorPtr++;
++- const float imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = sqrtf((real*real) + (imag*imag));
++- }
+++ unsigned int number;
+++ unsigned int quarter_points = num_points / 4;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++
+++ float32x4x2_t complex_vec;
+++ float32x4_t magnitude_vec;
+++ for (number = 0; number < quarter_points; number++) {
+++ complex_vec = vld2q_f32(complexVectorPtr);
+++ complex_vec.val[0] = vmulq_f32(complex_vec.val[0], complex_vec.val[0]);
+++ magnitude_vec =
+++ vmlaq_f32(complex_vec.val[0], complex_vec.val[1], complex_vec.val[1]);
+++ magnitude_vec = vrsqrteq_f32(magnitude_vec);
+++ magnitude_vec = vrecpeq_f32(magnitude_vec); // no plain ol' sqrt
+++ vst1q_f32(magnitudeVectorPtr, magnitude_vec);
+++
+++ complexVectorPtr += 8;
+++ magnitudeVectorPtr += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ const float real = *complexVectorPtr++;
+++ const float imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = sqrtf((real * real) + (imag * imag));
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_NEON
++ /*!
++- \brief Calculates the magnitude of the complexVector and stores the results in the magnitudeVector
+++ \brief Calculates the magnitude of the complexVector and stores the results in the
+++ magnitudeVector
++
++ This is an approximation from "Streamlining Digital Signal Processing" by
++ Richard Lyons. Apparently max error is about 1% and mean error is about 0.6%.
++@@ -387,80 +389,80 @@ volk_32fc_magnitude_32f_neon(float* magnitudeVector, const lv_32fc_t* complexVec
++
++ \param complexVector The vector containing the complex input values
++ \param magnitudeVector The vector containing the real output values
++- \param num_points The number of complex values in complexVector to be calculated and stored into cVector
+++ \param num_points The number of complex values in complexVector to be calculated and
+++ stored into cVector
++ */
++-static inline void
++-volk_32fc_magnitude_32f_neon_fancy_sweet(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_32f_neon_fancy_sweet(
+++ float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points)
++ {
++- unsigned int number;
++- unsigned int quarter_points = num_points / 4;
++- const float* complexVectorPtr = (float*)complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++-
++- const float threshold = 0.4142135;
++-
++- float32x4_t a_vec, b_vec, a_high, a_low, b_high, b_low;
++- a_high = vdupq_n_f32( 0.84 );
++- b_high = vdupq_n_f32( 0.561);
++- a_low = vdupq_n_f32( 0.99 );
++- b_low = vdupq_n_f32( 0.197);
++-
++- uint32x4_t comp0, comp1;
++-
++- float32x4x2_t complex_vec;
++- float32x4_t min_vec, max_vec, magnitude_vec;
++- float32x4_t real_abs, imag_abs;
++- for(number = 0; number < quarter_points; number++){
++- complex_vec = vld2q_f32(complexVectorPtr);
++-
++- real_abs = vabsq_f32(complex_vec.val[0]);
++- imag_abs = vabsq_f32(complex_vec.val[1]);
++-
++- min_vec = vminq_f32(real_abs, imag_abs);
++- max_vec = vmaxq_f32(real_abs, imag_abs);
++-
++- // effective branch to choose coefficient pair.
++- comp0 = vcgtq_f32(min_vec, vmulq_n_f32(max_vec, threshold));
++- comp1 = vcleq_f32(min_vec, vmulq_n_f32(max_vec, threshold));
++-
++- // and 0s or 1s with coefficients from previous effective branch
++- a_vec = (float32x4_t)vaddq_s32(vandq_s32((int32x4_t)comp0, (int32x4_t)a_high),
++- vandq_s32((int32x4_t)comp1, (int32x4_t)a_low));
++- b_vec = (float32x4_t)vaddq_s32(vandq_s32((int32x4_t)comp0, (int32x4_t)b_high),
++- vandq_s32((int32x4_t)comp1, (int32x4_t)b_low));
++-
++- // coefficients chosen, do the weighted sum
++- min_vec = vmulq_f32(min_vec, b_vec);
++- max_vec = vmulq_f32(max_vec, a_vec);
++-
++- magnitude_vec = vaddq_f32(min_vec, max_vec);
++- vst1q_f32(magnitudeVectorPtr, magnitude_vec);
++-
++- complexVectorPtr += 8;
++- magnitudeVectorPtr += 4;
++- }
++-
++- for(number = quarter_points*4; number < num_points; number++){
++- const float real = *complexVectorPtr++;
++- const float imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = sqrtf((real*real) + (imag*imag));
++- }
+++ unsigned int number;
+++ unsigned int quarter_points = num_points / 4;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++
+++ const float threshold = 0.4142135;
+++
+++ float32x4_t a_vec, b_vec, a_high, a_low, b_high, b_low;
+++ a_high = vdupq_n_f32(0.84);
+++ b_high = vdupq_n_f32(0.561);
+++ a_low = vdupq_n_f32(0.99);
+++ b_low = vdupq_n_f32(0.197);
+++
+++ uint32x4_t comp0, comp1;
+++
+++ float32x4x2_t complex_vec;
+++ float32x4_t min_vec, max_vec, magnitude_vec;
+++ float32x4_t real_abs, imag_abs;
+++ for (number = 0; number < quarter_points; number++) {
+++ complex_vec = vld2q_f32(complexVectorPtr);
+++
+++ real_abs = vabsq_f32(complex_vec.val[0]);
+++ imag_abs = vabsq_f32(complex_vec.val[1]);
+++
+++ min_vec = vminq_f32(real_abs, imag_abs);
+++ max_vec = vmaxq_f32(real_abs, imag_abs);
+++
+++ // effective branch to choose coefficient pair.
+++ comp0 = vcgtq_f32(min_vec, vmulq_n_f32(max_vec, threshold));
+++ comp1 = vcleq_f32(min_vec, vmulq_n_f32(max_vec, threshold));
+++
+++ // and 0s or 1s with coefficients from previous effective branch
+++ a_vec = (float32x4_t)vaddq_s32(vandq_s32((int32x4_t)comp0, (int32x4_t)a_high),
+++ vandq_s32((int32x4_t)comp1, (int32x4_t)a_low));
+++ b_vec = (float32x4_t)vaddq_s32(vandq_s32((int32x4_t)comp0, (int32x4_t)b_high),
+++ vandq_s32((int32x4_t)comp1, (int32x4_t)b_low));
+++
+++ // coefficients chosen, do the weighted sum
+++ min_vec = vmulq_f32(min_vec, b_vec);
+++ max_vec = vmulq_f32(max_vec, a_vec);
+++
+++ magnitude_vec = vaddq_f32(min_vec, max_vec);
+++ vst1q_f32(magnitudeVectorPtr, magnitude_vec);
+++
+++ complexVectorPtr += 8;
+++ magnitudeVectorPtr += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ const float real = *complexVectorPtr++;
+++ const float imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = sqrtf((real * real) + (imag * imag));
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_ORC
++
++-extern void
++-volk_32fc_magnitude_32f_a_orc_impl(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points);
+++extern void volk_32fc_magnitude_32f_a_orc_impl(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points);
++
++-static inline void
++-volk_32fc_magnitude_32f_u_orc(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_32f_u_orc(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- volk_32fc_magnitude_32f_a_orc_impl(magnitudeVector, complexVector, num_points);
+++ volk_32fc_magnitude_32f_a_orc_impl(magnitudeVector, complexVector, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++diff --git a/kernels/volk/volk_32fc_magnitude_squared_32f.h b/kernels/volk/volk_32fc_magnitude_squared_32f.h
++index 51bb4df..cb093ca 100644
++--- a/kernels/volk/volk_32fc_magnitude_squared_32f.h
+++++ b/kernels/volk/volk_32fc_magnitude_squared_32f.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_magnitude_squared_32f(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_magnitude_squared_32f(float* magnitudeVector, const lv_32fc_t*
+++ * complexVector, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -72,41 +72,41 @@
++ #define INCLUDED_volk_32fc_magnitude_squared_32f_u_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void
++-volk_32fc_magnitude_squared_32f_u_avx(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_squared_32f_u_avx(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* complexVectorPtr = (float*) complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++-
++- __m256 cplxValue1, cplxValue2, result;
++-
++- for(; number < eighthPoints; number++){
++- cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
++- cplxValue2 = _mm256_loadu_ps(complexVectorPtr + 8);
++- result = _mm256_magnitudesquared_ps(cplxValue1, cplxValue2);
++- _mm256_storeu_ps(magnitudeVectorPtr, result);
++-
++- complexVectorPtr += 16;
++- magnitudeVectorPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- float val1Real = *complexVectorPtr++;
++- float val1Imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
++- }
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++
+++ __m256 cplxValue1, cplxValue2, result;
+++
+++ for (; number < eighthPoints; number++) {
+++ cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
+++ cplxValue2 = _mm256_loadu_ps(complexVectorPtr + 8);
+++ result = _mm256_magnitudesquared_ps(cplxValue1, cplxValue2);
+++ _mm256_storeu_ps(magnitudeVectorPtr, result);
+++
+++ complexVectorPtr += 16;
+++ magnitudeVectorPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ float val1Real = *complexVectorPtr++;
+++ float val1Imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -115,137 +115,136 @@ volk_32fc_magnitude_squared_32f_u_avx(float* magnitudeVector, const lv_32fc_t* c
++ #include <pmmintrin.h>
++ #include <volk/volk_sse3_intrinsics.h>
++
++-static inline void
++-volk_32fc_magnitude_squared_32f_u_sse3(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_squared_32f_u_sse3(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* complexVectorPtr = (float*) complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++-
++- __m128 cplxValue1, cplxValue2, result;
++- for(; number < quarterPoints; number++){
++- cplxValue1 = _mm_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- cplxValue2 = _mm_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- result = _mm_magnitudesquared_ps_sse3(cplxValue1, cplxValue2);
++- _mm_storeu_ps(magnitudeVectorPtr, result);
++- magnitudeVectorPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- float val1Real = *complexVectorPtr++;
++- float val1Imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++
+++ __m128 cplxValue1, cplxValue2, result;
+++ for (; number < quarterPoints; number++) {
+++ cplxValue1 = _mm_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ cplxValue2 = _mm_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ result = _mm_magnitudesquared_ps_sse3(cplxValue1, cplxValue2);
+++ _mm_storeu_ps(magnitudeVectorPtr, result);
+++ magnitudeVectorPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ float val1Real = *complexVectorPtr++;
+++ float val1Imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
+++ }
++ }
++ #endif /* LV_HAVE_SSE3 */
++
++
++ #ifdef LV_HAVE_SSE
++-#include <xmmintrin.h>
++ #include <volk/volk_sse_intrinsics.h>
+++#include <xmmintrin.h>
++
++-static inline void
++-volk_32fc_magnitude_squared_32f_u_sse(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_squared_32f_u_sse(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* complexVectorPtr = (float*) complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
++
++- __m128 cplxValue1, cplxValue2, result;
+++ __m128 cplxValue1, cplxValue2, result;
++
++- for(; number < quarterPoints; number++){
++- cplxValue1 = _mm_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ for (; number < quarterPoints; number++) {
+++ cplxValue1 = _mm_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- cplxValue2 = _mm_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ cplxValue2 = _mm_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- result = _mm_magnitudesquared_ps(cplxValue1, cplxValue2);
++- _mm_storeu_ps(magnitudeVectorPtr, result);
++- magnitudeVectorPtr += 4;
++- }
+++ result = _mm_magnitudesquared_ps(cplxValue1, cplxValue2);
+++ _mm_storeu_ps(magnitudeVectorPtr, result);
+++ magnitudeVectorPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- float val1Real = *complexVectorPtr++;
++- float val1Imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ float val1Real = *complexVectorPtr++;
+++ float val1Imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_magnitude_squared_32f_generic(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_squared_32f_generic(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- const float* complexVectorPtr = (float*)complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++- unsigned int number = 0;
++- for(number = 0; number < num_points; number++){
++- const float real = *complexVectorPtr++;
++- const float imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = (real*real) + (imag*imag);
++- }
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++ unsigned int number = 0;
+++ for (number = 0; number < num_points; number++) {
+++ const float real = *complexVectorPtr++;
+++ const float imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = (real * real) + (imag * imag);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++ #endif /* INCLUDED_volk_32fc_magnitude_32f_u_H */
++ #ifndef INCLUDED_volk_32fc_magnitude_squared_32f_a_H
++ #define INCLUDED_volk_32fc_magnitude_squared_32f_a_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void
++-volk_32fc_magnitude_squared_32f_a_avx(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_squared_32f_a_avx(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* complexVectorPtr = (float*) complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++-
++- __m256 cplxValue1, cplxValue2, result;
++- for(; number < eighthPoints; number++){
++- cplxValue1 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- cplxValue2 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- result = _mm256_magnitudesquared_ps(cplxValue1, cplxValue2);
++- _mm256_store_ps(magnitudeVectorPtr, result);
++- magnitudeVectorPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- float val1Real = *complexVectorPtr++;
++- float val1Imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
++- }
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++
+++ __m256 cplxValue1, cplxValue2, result;
+++ for (; number < eighthPoints; number++) {
+++ cplxValue1 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ cplxValue2 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ result = _mm256_magnitudesquared_ps(cplxValue1, cplxValue2);
+++ _mm256_store_ps(magnitudeVectorPtr, result);
+++ magnitudeVectorPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ float val1Real = *complexVectorPtr++;
+++ float val1Imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -254,72 +253,72 @@ volk_32fc_magnitude_squared_32f_a_avx(float* magnitudeVector, const lv_32fc_t* c
++ #include <pmmintrin.h>
++ #include <volk/volk_sse3_intrinsics.h>
++
++-static inline void
++-volk_32fc_magnitude_squared_32f_a_sse3(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_squared_32f_a_sse3(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* complexVectorPtr = (float*) complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++-
++- __m128 cplxValue1, cplxValue2, result;
++- for(; number < quarterPoints; number++){
++- cplxValue1 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- cplxValue2 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- result = _mm_magnitudesquared_ps_sse3(cplxValue1, cplxValue2);
++- _mm_store_ps(magnitudeVectorPtr, result);
++- magnitudeVectorPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- float val1Real = *complexVectorPtr++;
++- float val1Imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++
+++ __m128 cplxValue1, cplxValue2, result;
+++ for (; number < quarterPoints; number++) {
+++ cplxValue1 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ cplxValue2 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ result = _mm_magnitudesquared_ps_sse3(cplxValue1, cplxValue2);
+++ _mm_store_ps(magnitudeVectorPtr, result);
+++ magnitudeVectorPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ float val1Real = *complexVectorPtr++;
+++ float val1Imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
+++ }
++ }
++ #endif /* LV_HAVE_SSE3 */
++
++
++ #ifdef LV_HAVE_SSE
++-#include <xmmintrin.h>
++ #include <volk/volk_sse_intrinsics.h>
+++#include <xmmintrin.h>
++
++-static inline void
++-volk_32fc_magnitude_squared_32f_a_sse(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_squared_32f_a_sse(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* complexVectorPtr = (float*)complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++-
++- __m128 cplxValue1, cplxValue2, result;
++- for(;number < quarterPoints; number++){
++- cplxValue1 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- cplxValue2 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++-
++- result = _mm_magnitudesquared_ps(cplxValue1, cplxValue2);
++- _mm_store_ps(magnitudeVectorPtr, result);
++- magnitudeVectorPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- float val1Real = *complexVectorPtr++;
++- float val1Imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++
+++ __m128 cplxValue1, cplxValue2, result;
+++ for (; number < quarterPoints; number++) {
+++ cplxValue1 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ cplxValue2 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++
+++ result = _mm_magnitudesquared_ps(cplxValue1, cplxValue2);
+++ _mm_store_ps(magnitudeVectorPtr, result);
+++ magnitudeVectorPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ float val1Real = *complexVectorPtr++;
+++ float val1Imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -327,55 +326,57 @@ volk_32fc_magnitude_squared_32f_a_sse(float* magnitudeVector, const lv_32fc_t* c
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32fc_magnitude_squared_32f_neon(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_squared_32f_neon(float* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- const float* complexVectorPtr = (float*)complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++-
++- float32x4x2_t cmplx_val;
++- float32x4_t result;
++- for(;number < quarterPoints; number++){
++- cmplx_val = vld2q_f32(complexVectorPtr);
++- complexVectorPtr += 8;
++-
++- cmplx_val.val[0] = vmulq_f32(cmplx_val.val[0], cmplx_val.val[0]); // Square the values
++- cmplx_val.val[1] = vmulq_f32(cmplx_val.val[1], cmplx_val.val[1]); // Square the values
++-
++- result = vaddq_f32(cmplx_val.val[0], cmplx_val.val[1]); // Add the I2 and Q2 values
++-
++- vst1q_f32(magnitudeVectorPtr, result);
++- magnitudeVectorPtr += 4;
++- }
++-
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- float val1Real = *complexVectorPtr++;
++- float val1Imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++
+++ float32x4x2_t cmplx_val;
+++ float32x4_t result;
+++ for (; number < quarterPoints; number++) {
+++ cmplx_val = vld2q_f32(complexVectorPtr);
+++ complexVectorPtr += 8;
+++
+++ cmplx_val.val[0] =
+++ vmulq_f32(cmplx_val.val[0], cmplx_val.val[0]); // Square the values
+++ cmplx_val.val[1] =
+++ vmulq_f32(cmplx_val.val[1], cmplx_val.val[1]); // Square the values
+++
+++ result =
+++ vaddq_f32(cmplx_val.val[0], cmplx_val.val[1]); // Add the I2 and Q2 values
+++
+++ vst1q_f32(magnitudeVectorPtr, result);
+++ magnitudeVectorPtr += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ float val1Real = *complexVectorPtr++;
+++ float val1Imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = (val1Real * val1Real) + (val1Imag * val1Imag);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_magnitude_squared_32f_a_generic(float* magnitudeVector, const lv_32fc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_32fc_magnitude_squared_32f_a_generic(
+++ float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points)
++ {
++- const float* complexVectorPtr = (float*)complexVector;
++- float* magnitudeVectorPtr = magnitudeVector;
++- unsigned int number = 0;
++- for(number = 0; number < num_points; number++){
++- const float real = *complexVectorPtr++;
++- const float imag = *complexVectorPtr++;
++- *magnitudeVectorPtr++ = (real*real) + (imag*imag);
++- }
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* magnitudeVectorPtr = magnitudeVector;
+++ unsigned int number = 0;
+++ for (number = 0; number < num_points; number++) {
+++ const float real = *complexVectorPtr++;
+++ const float imag = *complexVectorPtr++;
+++ *magnitudeVectorPtr++ = (real * real) + (imag * imag);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32fc_s32f_atan2_32f.h b/kernels/volk/volk_32fc_s32f_atan2_32f.h
++index c169336..f08f793 100644
++--- a/kernels/volk/volk_32fc_s32f_atan2_32f.h
+++++ b/kernels/volk/volk_32fc_s32f_atan2_32f.h
++@@ -30,13 +30,13 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_s32f_atan2_32f(float* outputVector, const lv_32fc_t* complexVector, const float normalizeFactor, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_s32f_atan2_32f(float* outputVector, const lv_32fc_t* complexVector,
+++ * const float normalizeFactor, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++- * \li inputVector: The byte-aligned input vector containing interleaved IQ data (I = cos, Q = sin).
++- * \li normalizeFactor: The atan results are divided by this normalization factor.
++- * \li num_points: The number of complex values in \p inputVector.
+++ * \li inputVector: The byte-aligned input vector containing interleaved IQ data (I = cos,
+++ * Q = sin). \li normalizeFactor: The atan results are divided by this normalization
+++ * factor. \li num_points: The number of complex values in \p inputVector.
++ *
++ * \b Outputs
++ * \li outputVector: The vector where the results will be stored.
++@@ -75,8 +75,8 @@
++ #define INCLUDED_volk_32fc_s32f_atan2_32f_a_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++@@ -85,50 +85,54 @@
++ #include <simdmath.h>
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++
++-static inline void volk_32fc_s32f_atan2_32f_a_sse4_1(float* outputVector, const lv_32fc_t* complexVector, const float normalizeFactor, unsigned int num_points){
++- const float* complexVectorPtr = (float*)complexVector;
++- float* outPtr = outputVector;
+++static inline void volk_32fc_s32f_atan2_32f_a_sse4_1(float* outputVector,
+++ const lv_32fc_t* complexVector,
+++ const float normalizeFactor,
+++ unsigned int num_points)
+++{
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* outPtr = outputVector;
++
++- unsigned int number = 0;
++- const float invNormalizeFactor = 1.0 / normalizeFactor;
+++ unsigned int number = 0;
+++ const float invNormalizeFactor = 1.0 / normalizeFactor;
++
++ #ifdef LV_HAVE_LIB_SIMDMATH
++- const unsigned int quarterPoints = num_points / 4;
++- __m128 testVector = _mm_set_ps1(2*M_PI);
++- __m128 correctVector = _mm_set_ps1(M_PI);
++- __m128 vNormalizeFactor = _mm_set_ps1(invNormalizeFactor);
++- __m128 phase;
++- __m128 complex1, complex2, iValue, qValue;
++- __m128 keepMask;
++-
++- for (; number < quarterPoints; number++) {
++- // Load IQ data:
++- complex1 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++- complex2 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++- // Deinterleave IQ data:
++- iValue = _mm_shuffle_ps(complex1, complex2, _MM_SHUFFLE(2,0,2,0));
++- qValue = _mm_shuffle_ps(complex1, complex2, _MM_SHUFFLE(3,1,3,1));
++- // Arctan to get phase:
++- phase = atan2f4(qValue, iValue);
++- // When Q = 0 and I < 0, atan2f4 sucks and returns 2pi vice pi.
++- // Compare to 2pi:
++- keepMask = _mm_cmpneq_ps(phase,testVector);
++- phase = _mm_blendv_ps(correctVector, phase, keepMask);
++- // done with above correction.
++- phase = _mm_mul_ps(phase, vNormalizeFactor);
++- _mm_store_ps((float*)outPtr, phase);
++- outPtr += 4;
++- }
++- number = quarterPoints * 4;
+++ const unsigned int quarterPoints = num_points / 4;
+++ __m128 testVector = _mm_set_ps1(2 * M_PI);
+++ __m128 correctVector = _mm_set_ps1(M_PI);
+++ __m128 vNormalizeFactor = _mm_set_ps1(invNormalizeFactor);
+++ __m128 phase;
+++ __m128 complex1, complex2, iValue, qValue;
+++ __m128 keepMask;
+++
+++ for (; number < quarterPoints; number++) {
+++ // Load IQ data:
+++ complex1 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++ complex2 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++ // Deinterleave IQ data:
+++ iValue = _mm_shuffle_ps(complex1, complex2, _MM_SHUFFLE(2, 0, 2, 0));
+++ qValue = _mm_shuffle_ps(complex1, complex2, _MM_SHUFFLE(3, 1, 3, 1));
+++ // Arctan to get phase:
+++ phase = atan2f4(qValue, iValue);
+++ // When Q = 0 and I < 0, atan2f4 sucks and returns 2pi vice pi.
+++ // Compare to 2pi:
+++ keepMask = _mm_cmpneq_ps(phase, testVector);
+++ phase = _mm_blendv_ps(correctVector, phase, keepMask);
+++ // done with above correction.
+++ phase = _mm_mul_ps(phase, vNormalizeFactor);
+++ _mm_store_ps((float*)outPtr, phase);
+++ outPtr += 4;
+++ }
+++ number = quarterPoints * 4;
++ #endif /* LV_HAVE_SIMDMATH_H */
++
++- for (; number < num_points; number++) {
++- const float real = *complexVectorPtr++;
++- const float imag = *complexVectorPtr++;
++- *outPtr++ = atan2f(imag, real) * invNormalizeFactor;
++- }
+++ for (; number < num_points; number++) {
+++ const float real = *complexVectorPtr++;
+++ const float imag = *complexVectorPtr++;
+++ *outPtr++ = atan2f(imag, real) * invNormalizeFactor;
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++@@ -140,72 +144,78 @@ static inline void volk_32fc_s32f_atan2_32f_a_sse4_1(float* outputVector, const
++ #include <simdmath.h>
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++
++-static inline void volk_32fc_s32f_atan2_32f_a_sse(float* outputVector, const lv_32fc_t* complexVector, const float normalizeFactor, unsigned int num_points){
++- const float* complexVectorPtr = (float*)complexVector;
++- float* outPtr = outputVector;
+++static inline void volk_32fc_s32f_atan2_32f_a_sse(float* outputVector,
+++ const lv_32fc_t* complexVector,
+++ const float normalizeFactor,
+++ unsigned int num_points)
+++{
+++ const float* complexVectorPtr = (float*)complexVector;
+++ float* outPtr = outputVector;
++
++- unsigned int number = 0;
++- const float invNormalizeFactor = 1.0 / normalizeFactor;
+++ unsigned int number = 0;
+++ const float invNormalizeFactor = 1.0 / normalizeFactor;
++
++ #ifdef LV_HAVE_LIB_SIMDMATH
++- const unsigned int quarterPoints = num_points / 4;
++- __m128 testVector = _mm_set_ps1(2*M_PI);
++- __m128 correctVector = _mm_set_ps1(M_PI);
++- __m128 vNormalizeFactor = _mm_set_ps1(invNormalizeFactor);
++- __m128 phase;
++- __m128 complex1, complex2, iValue, qValue;
++- __m128 mask;
++- __m128 keepMask;
++-
++- for (; number < quarterPoints; number++) {
++- // Load IQ data:
++- complex1 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++- complex2 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
++- // Deinterleave IQ data:
++- iValue = _mm_shuffle_ps(complex1, complex2, _MM_SHUFFLE(2,0,2,0));
++- qValue = _mm_shuffle_ps(complex1, complex2, _MM_SHUFFLE(3,1,3,1));
++- // Arctan to get phase:
++- phase = atan2f4(qValue, iValue);
++- // When Q = 0 and I < 0, atan2f4 sucks and returns 2pi vice pi.
++- // Compare to 2pi:
++- keepMask = _mm_cmpneq_ps(phase,testVector);
++- phase = _mm_and_ps(phase, keepMask);
++- mask = _mm_andnot_ps(keepMask, correctVector);
++- phase = _mm_or_ps(phase, mask);
++- // done with above correction.
++- phase = _mm_mul_ps(phase, vNormalizeFactor);
++- _mm_store_ps((float*)outPtr, phase);
++- outPtr += 4;
++- }
++- number = quarterPoints * 4;
+++ const unsigned int quarterPoints = num_points / 4;
+++ __m128 testVector = _mm_set_ps1(2 * M_PI);
+++ __m128 correctVector = _mm_set_ps1(M_PI);
+++ __m128 vNormalizeFactor = _mm_set_ps1(invNormalizeFactor);
+++ __m128 phase;
+++ __m128 complex1, complex2, iValue, qValue;
+++ __m128 mask;
+++ __m128 keepMask;
+++
+++ for (; number < quarterPoints; number++) {
+++ // Load IQ data:
+++ complex1 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++ complex2 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
+++ // Deinterleave IQ data:
+++ iValue = _mm_shuffle_ps(complex1, complex2, _MM_SHUFFLE(2, 0, 2, 0));
+++ qValue = _mm_shuffle_ps(complex1, complex2, _MM_SHUFFLE(3, 1, 3, 1));
+++ // Arctan to get phase:
+++ phase = atan2f4(qValue, iValue);
+++ // When Q = 0 and I < 0, atan2f4 sucks and returns 2pi vice pi.
+++ // Compare to 2pi:
+++ keepMask = _mm_cmpneq_ps(phase, testVector);
+++ phase = _mm_and_ps(phase, keepMask);
+++ mask = _mm_andnot_ps(keepMask, correctVector);
+++ phase = _mm_or_ps(phase, mask);
+++ // done with above correction.
+++ phase = _mm_mul_ps(phase, vNormalizeFactor);
+++ _mm_store_ps((float*)outPtr, phase);
+++ outPtr += 4;
+++ }
+++ number = quarterPoints * 4;
++ #endif /* LV_HAVE_SIMDMATH_H */
++
++- for (; number < num_points; number++) {
++- const float real = *complexVectorPtr++;
++- const float imag = *complexVectorPtr++;
++- *outPtr++ = atan2f(imag, real) * invNormalizeFactor;
++- }
+++ for (; number < num_points; number++) {
+++ const float real = *complexVectorPtr++;
+++ const float imag = *complexVectorPtr++;
+++ *outPtr++ = atan2f(imag, real) * invNormalizeFactor;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32fc_s32f_atan2_32f_generic(float* outputVector, const lv_32fc_t* inputVector, const float normalizeFactor, unsigned int num_points){
++- float* outPtr = outputVector;
++- const float* inPtr = (float*)inputVector;
++- const float invNormalizeFactor = 1.0 / normalizeFactor;
++- unsigned int number;
++- for ( number = 0; number < num_points; number++) {
++- const float real = *inPtr++;
++- const float imag = *inPtr++;
++- *outPtr++ = atan2f(imag, real) * invNormalizeFactor;
++- }
+++static inline void volk_32fc_s32f_atan2_32f_generic(float* outputVector,
+++ const lv_32fc_t* inputVector,
+++ const float normalizeFactor,
+++ unsigned int num_points)
+++{
+++ float* outPtr = outputVector;
+++ const float* inPtr = (float*)inputVector;
+++ const float invNormalizeFactor = 1.0 / normalizeFactor;
+++ unsigned int number;
+++ for (number = 0; number < num_points; number++) {
+++ const float real = *inPtr++;
+++ const float imag = *inPtr++;
+++ *outPtr++ = atan2f(imag, real) * invNormalizeFactor;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++-
++ #endif /* INCLUDED_volk_32fc_s32f_atan2_32f_a_H */
++diff --git a/kernels/volk/volk_32fc_s32f_deinterleave_real_16i.h b/kernels/volk/volk_32fc_s32f_deinterleave_real_16i.h
++index 64c6a8b..f70f494 100644
++--- a/kernels/volk/volk_32fc_s32f_deinterleave_real_16i.h
+++++ b/kernels/volk/volk_32fc_s32f_deinterleave_real_16i.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_s32f_deinterleave_real_16i(int16_t* iBuffer, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_s32f_deinterleave_real_16i(int16_t* iBuffer, const lv_32fc_t*
+++ * complexVector, const float scalar, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -73,61 +73,62 @@
++ #ifndef INCLUDED_volk_32fc_s32f_deinterleave_real_16i_a_H
++ #define INCLUDED_volk_32fc_s32f_deinterleave_real_16i_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++ static inline void
++-volk_32fc_s32f_deinterleave_real_16i_a_avx2(int16_t* iBuffer, const lv_32fc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_32fc_s32f_deinterleave_real_16i_a_avx2(int16_t* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* complexVectorPtr = (float*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- __m256 vScalar = _mm256_set1_ps(scalar);
+++ const float* complexVectorPtr = (float*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
++
++- __m256 cplxValue1, cplxValue2, iValue;
++- __m256i a;
++- __m128i b;
+++ __m256 vScalar = _mm256_set1_ps(scalar);
++
++- __m256i idx = _mm256_set_epi32(3,3,3,3,5,1,4,0);
+++ __m256 cplxValue1, cplxValue2, iValue;
+++ __m256i a;
+++ __m128i b;
++
++- for(;number < eighthPoints; number++){
++- cplxValue1 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ __m256i idx = _mm256_set_epi32(3, 3, 3, 3, 5, 1, 4, 0);
++
++- cplxValue2 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ for (; number < eighthPoints; number++) {
+++ cplxValue1 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- // Arrange in i1i2i3i4 format
++- iValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
+++ cplxValue2 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- iValue = _mm256_mul_ps(iValue, vScalar);
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
++
++- iValue = _mm256_round_ps(iValue, _MM_FROUND_TO_ZERO);
++- a = _mm256_cvtps_epi32(iValue);
++- a = _mm256_packs_epi32(a,a);
++- a = _mm256_permutevar8x32_epi32(a,idx);
++- b = _mm256_extracti128_si256(a,0);
+++ iValue = _mm256_mul_ps(iValue, vScalar);
++
++- _mm_store_si128((__m128i*)iBufferPtr,b);
++- iBufferPtr += 8;
+++ iValue = _mm256_round_ps(iValue, _MM_FROUND_TO_ZERO);
+++ a = _mm256_cvtps_epi32(iValue);
+++ a = _mm256_packs_epi32(a, a);
+++ a = _mm256_permutevar8x32_epi32(a, idx);
+++ b = _mm256_extracti128_si256(a, 0);
++
++- }
+++ _mm_store_si128((__m128i*)iBufferPtr, b);
+++ iBufferPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- iBufferPtr = &iBuffer[number];
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (int16_t)(*complexVectorPtr++ * scalar);
++- complexVectorPtr++;
++- }
+++ number = eighthPoints * 8;
+++ iBufferPtr = &iBuffer[number];
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (int16_t)(*complexVectorPtr++ * scalar);
+++ complexVectorPtr++;
+++ }
++ }
++
++
++@@ -137,46 +138,48 @@ volk_32fc_s32f_deinterleave_real_16i_a_avx2(int16_t* iBuffer, const lv_32fc_t* c
++ #include <xmmintrin.h>
++
++ static inline void
++-volk_32fc_s32f_deinterleave_real_16i_a_sse(int16_t* iBuffer, const lv_32fc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_32fc_s32f_deinterleave_real_16i_a_sse(int16_t* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* complexVectorPtr = (float*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
+++ const float* complexVectorPtr = (float*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
++
++- __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 vScalar = _mm_set_ps1(scalar);
++
++- __m128 cplxValue1, cplxValue2, iValue;
+++ __m128 cplxValue1, cplxValue2, iValue;
++
++- __VOLK_ATTR_ALIGNED(16) float floatBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float floatBuffer[4];
++
++- for(;number < quarterPoints; number++){
++- cplxValue1 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ for (; number < quarterPoints; number++) {
+++ cplxValue1 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- cplxValue2 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ cplxValue2 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- // Arrange in i1i2i3i4 format
++- iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
++
++- iValue = _mm_mul_ps(iValue, vScalar);
+++ iValue = _mm_mul_ps(iValue, vScalar);
++
++- _mm_store_ps(floatBuffer, iValue);
++- *iBufferPtr++ = (int16_t)(floatBuffer[0]);
++- *iBufferPtr++ = (int16_t)(floatBuffer[1]);
++- *iBufferPtr++ = (int16_t)(floatBuffer[2]);
++- *iBufferPtr++ = (int16_t)(floatBuffer[3]);
++- }
+++ _mm_store_ps(floatBuffer, iValue);
+++ *iBufferPtr++ = (int16_t)(floatBuffer[0]);
+++ *iBufferPtr++ = (int16_t)(floatBuffer[1]);
+++ *iBufferPtr++ = (int16_t)(floatBuffer[2]);
+++ *iBufferPtr++ = (int16_t)(floatBuffer[3]);
+++ }
++
++- number = quarterPoints * 4;
++- iBufferPtr = &iBuffer[number];
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (int16_t)(*complexVectorPtr++ * scalar);
++- complexVectorPtr++;
++- }
+++ number = quarterPoints * 4;
+++ iBufferPtr = &iBuffer[number];
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (int16_t)(*complexVectorPtr++ * scalar);
+++ complexVectorPtr++;
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE */
++@@ -185,16 +188,18 @@ volk_32fc_s32f_deinterleave_real_16i_a_sse(int16_t* iBuffer, const lv_32fc_t* co
++ #ifdef LV_HAVE_GENERIC
++
++ static inline void
++-volk_32fc_s32f_deinterleave_real_16i_generic(int16_t* iBuffer, const lv_32fc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_32fc_s32f_deinterleave_real_16i_generic(int16_t* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- const float* complexVectorPtr = (float*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- unsigned int number = 0;
++- for(number = 0; number < num_points; number++){
++- *iBufferPtr++ = (int16_t)(*complexVectorPtr++ * scalar);
++- complexVectorPtr++;
++- }
+++ const float* complexVectorPtr = (float*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ unsigned int number = 0;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = (int16_t)(*complexVectorPtr++ * scalar);
+++ complexVectorPtr++;
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -204,60 +209,61 @@ volk_32fc_s32f_deinterleave_real_16i_generic(int16_t* iBuffer, const lv_32fc_t*
++ #ifndef INCLUDED_volk_32fc_s32f_deinterleave_real_16i_u_H
++ #define INCLUDED_volk_32fc_s32f_deinterleave_real_16i_u_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++ static inline void
++-volk_32fc_s32f_deinterleave_real_16i_u_avx2(int16_t* iBuffer, const lv_32fc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_32fc_s32f_deinterleave_real_16i_u_avx2(int16_t* iBuffer,
+++ const lv_32fc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++-
++- const float* complexVectorPtr = (float*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- __m256 vScalar = _mm256_set1_ps(scalar);
+++ const float* complexVectorPtr = (float*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
++
++- __m256 cplxValue1, cplxValue2, iValue;
++- __m256i a;
++- __m128i b;
+++ __m256 vScalar = _mm256_set1_ps(scalar);
++
++- __m256i idx = _mm256_set_epi32(3,3,3,3,5,1,4,0);
+++ __m256 cplxValue1, cplxValue2, iValue;
+++ __m256i a;
+++ __m128i b;
++
++- for(;number < eighthPoints; number++){
++- cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ __m256i idx = _mm256_set_epi32(3, 3, 3, 3, 5, 1, 4, 0);
++
++- cplxValue2 = _mm256_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ for (; number < eighthPoints; number++) {
+++ cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- // Arrange in i1i2i3i4 format
++- iValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
+++ cplxValue2 = _mm256_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- iValue = _mm256_mul_ps(iValue, vScalar);
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm256_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
++
++- iValue = _mm256_round_ps(iValue, _MM_FROUND_TO_ZERO);
++- a = _mm256_cvtps_epi32(iValue);
++- a = _mm256_packs_epi32(a,a);
++- a = _mm256_permutevar8x32_epi32(a,idx);
++- b = _mm256_extracti128_si256(a,0);
+++ iValue = _mm256_mul_ps(iValue, vScalar);
++
++- _mm_storeu_si128((__m128i*)iBufferPtr,b);
++- iBufferPtr += 8;
+++ iValue = _mm256_round_ps(iValue, _MM_FROUND_TO_ZERO);
+++ a = _mm256_cvtps_epi32(iValue);
+++ a = _mm256_packs_epi32(a, a);
+++ a = _mm256_permutevar8x32_epi32(a, idx);
+++ b = _mm256_extracti128_si256(a, 0);
++
++- }
+++ _mm_storeu_si128((__m128i*)iBufferPtr, b);
+++ iBufferPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- iBufferPtr = &iBuffer[number];
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (int16_t)(*complexVectorPtr++ * scalar);
++- complexVectorPtr++;
++- }
+++ number = eighthPoints * 8;
+++ iBufferPtr = &iBuffer[number];
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (int16_t)(*complexVectorPtr++ * scalar);
+++ complexVectorPtr++;
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 */
++diff --git a/kernels/volk/volk_32fc_s32f_magnitude_16i.h b/kernels/volk/volk_32fc_s32f_magnitude_16i.h
++index 6e7e7cb..91a5b8e 100644
++--- a/kernels/volk/volk_32fc_s32f_magnitude_16i.h
+++++ b/kernels/volk/volk_32fc_s32f_magnitude_16i.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_s32f_magnitude_16i(int16_t* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_s32f_magnitude_16i(int16_t* magnitudeVector, const lv_32fc_t*
+++ * complexVector, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -73,123 +73,129 @@
++ #ifdef LV_HAVE_GENERIC
++ #include <volk/volk_common.h>
++
++-static inline void
++-volk_32fc_s32f_magnitude_16i_generic(int16_t* magnitudeVector, const lv_32fc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32fc_s32f_magnitude_16i_generic(int16_t* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- const float* complexVectorPtr = (float*)complexVector;
++- int16_t* magnitudeVectorPtr = magnitudeVector;
++- unsigned int number = 0;
++- for(number = 0; number < num_points; number++){
++- __VOLK_VOLATILE float real = *complexVectorPtr++;
++- __VOLK_VOLATILE float imag = *complexVectorPtr++;
++- real *= real;
++- imag *= imag;
++- *magnitudeVectorPtr++ = (int16_t)rintf(scalar*sqrtf(real + imag));
++- }
+++ const float* complexVectorPtr = (float*)complexVector;
+++ int16_t* magnitudeVectorPtr = magnitudeVector;
+++ unsigned int number = 0;
+++ for (number = 0; number < num_points; number++) {
+++ __VOLK_VOLATILE float real = *complexVectorPtr++;
+++ __VOLK_VOLATILE float imag = *complexVectorPtr++;
+++ real *= real;
+++ imag *= imag;
+++ *magnitudeVectorPtr++ = (int16_t)rintf(scalar * sqrtf(real + imag));
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifndef INCLUDED_volk_32fc_s32f_magnitude_16i_a_H
++ #define INCLUDED_volk_32fc_s32f_magnitude_16i_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_s32f_magnitude_16i_a_avx2(int16_t* magnitudeVector, const lv_32fc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32fc_s32f_magnitude_16i_a_avx2(int16_t* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- const float* complexVectorPtr = (const float*)complexVector;
++- int16_t* magnitudeVectorPtr = magnitudeVector;
+++ const float* complexVectorPtr = (const float*)complexVector;
+++ int16_t* magnitudeVectorPtr = magnitudeVector;
++
++- __m256 vScalar = _mm256_set1_ps(scalar);
++- __m256i idx = _mm256_set_epi32(0,0,0,0,5,1,4,0);
++- __m256 cplxValue1, cplxValue2, result;
++- __m256i resultInt;
++- __m128i resultShort;
+++ __m256 vScalar = _mm256_set1_ps(scalar);
+++ __m256i idx = _mm256_set_epi32(0, 0, 0, 0, 5, 1, 4, 0);
+++ __m256 cplxValue1, cplxValue2, result;
+++ __m256i resultInt;
+++ __m128i resultShort;
++
++- for(;number < eighthPoints; number++){
++- cplxValue1 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ for (; number < eighthPoints; number++) {
+++ cplxValue1 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- cplxValue2 = _mm256_load_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ cplxValue2 = _mm256_load_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
++- cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
++
++- result = _mm256_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
+++ result = _mm256_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
++
++- result = _mm256_sqrt_ps(result);
+++ result = _mm256_sqrt_ps(result);
++
++- result = _mm256_mul_ps(result, vScalar);
+++ result = _mm256_mul_ps(result, vScalar);
++
++- resultInt = _mm256_cvtps_epi32(result);
++- resultInt = _mm256_packs_epi32(resultInt, resultInt);
++- resultInt = _mm256_permutevar8x32_epi32(resultInt, idx); //permute to compensate for shuffling in hadd and packs
++- resultShort = _mm256_extracti128_si256(resultInt,0);
++- _mm_store_si128((__m128i*)magnitudeVectorPtr,resultShort);
++- magnitudeVectorPtr += 8;
++- }
+++ resultInt = _mm256_cvtps_epi32(result);
+++ resultInt = _mm256_packs_epi32(resultInt, resultInt);
+++ resultInt = _mm256_permutevar8x32_epi32(
+++ resultInt, idx); // permute to compensate for shuffling in hadd and packs
+++ resultShort = _mm256_extracti128_si256(resultInt, 0);
+++ _mm_store_si128((__m128i*)magnitudeVectorPtr, resultShort);
+++ magnitudeVectorPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- volk_32fc_s32f_magnitude_16i_generic(magnitudeVector+number, complexVector+number, scalar, num_points-number);
+++ number = eighthPoints * 8;
+++ volk_32fc_s32f_magnitude_16i_generic(
+++ magnitudeVector + number, complexVector + number, scalar, num_points - number);
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_SSE3
++ #include <pmmintrin.h>
++
++-static inline void
++-volk_32fc_s32f_magnitude_16i_a_sse3(int16_t* magnitudeVector, const lv_32fc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32fc_s32f_magnitude_16i_a_sse3(int16_t* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* complexVectorPtr = (const float*)complexVector;
++- int16_t* magnitudeVectorPtr = magnitudeVector;
+++ const float* complexVectorPtr = (const float*)complexVector;
+++ int16_t* magnitudeVectorPtr = magnitudeVector;
++
++- __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 vScalar = _mm_set_ps1(scalar);
++
++- __m128 cplxValue1, cplxValue2, result;
+++ __m128 cplxValue1, cplxValue2, result;
++
++- __VOLK_ATTR_ALIGNED(16) float floatBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float floatBuffer[4];
++
++- for(;number < quarterPoints; number++){
++- cplxValue1 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ for (; number < quarterPoints; number++) {
+++ cplxValue1 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- cplxValue2 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ cplxValue2 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values
++- cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values
+++ cplxValue1 = _mm_mul_ps(cplxValue1, cplxValue1); // Square the values
+++ cplxValue2 = _mm_mul_ps(cplxValue2, cplxValue2); // Square the Values
++
++- result = _mm_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
+++ result = _mm_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
++
++- result = _mm_sqrt_ps(result);
+++ result = _mm_sqrt_ps(result);
++
++- result = _mm_mul_ps(result, vScalar);
+++ result = _mm_mul_ps(result, vScalar);
++
++- _mm_store_ps(floatBuffer, result);
++- *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[0]);
++- *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[1]);
++- *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[2]);
++- *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[3]);
++- }
+++ _mm_store_ps(floatBuffer, result);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[0]);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[1]);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[2]);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[3]);
+++ }
++
++- number = quarterPoints * 4;
++- volk_32fc_s32f_magnitude_16i_generic(magnitudeVector+number, complexVector+number, scalar, num_points-number);
+++ number = quarterPoints * 4;
+++ volk_32fc_s32f_magnitude_16i_generic(
+++ magnitudeVector + number, complexVector + number, scalar, num_points - number);
++ }
++ #endif /* LV_HAVE_SSE3 */
++
++@@ -197,53 +203,57 @@ volk_32fc_s32f_magnitude_16i_a_sse3(int16_t* magnitudeVector, const lv_32fc_t* c
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32fc_s32f_magnitude_16i_a_sse(int16_t* magnitudeVector, const lv_32fc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32fc_s32f_magnitude_16i_a_sse(int16_t* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const float* complexVectorPtr = (const float*)complexVector;
++- int16_t* magnitudeVectorPtr = magnitudeVector;
+++ const float* complexVectorPtr = (const float*)complexVector;
+++ int16_t* magnitudeVectorPtr = magnitudeVector;
++
++- __m128 vScalar = _mm_set_ps1(scalar);
+++ __m128 vScalar = _mm_set_ps1(scalar);
++
++- __m128 cplxValue1, cplxValue2, result;
++- __m128 iValue, qValue;
+++ __m128 cplxValue1, cplxValue2, result;
+++ __m128 iValue, qValue;
++
++- __VOLK_ATTR_ALIGNED(16) float floatBuffer[4];
+++ __VOLK_ATTR_ALIGNED(16) float floatBuffer[4];
++
++- for(;number < quarterPoints; number++){
++- cplxValue1 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ for (; number < quarterPoints; number++) {
+++ cplxValue1 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- cplxValue2 = _mm_load_ps(complexVectorPtr);
++- complexVectorPtr += 4;
+++ cplxValue2 = _mm_load_ps(complexVectorPtr);
+++ complexVectorPtr += 4;
++
++- // Arrange in i1i2i3i4 format
++- iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
++- // Arrange in q1q2q3q4 format
++- qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
+++ // Arrange in q1q2q3q4 format
+++ qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3, 1, 3, 1));
++
++- __VOLK_VOLATILE __m128 iValue2 = _mm_mul_ps(iValue, iValue); // Square the I values
++- __VOLK_VOLATILE __m128 qValue2 = _mm_mul_ps(qValue, qValue); // Square the Q Values
+++ __VOLK_VOLATILE __m128 iValue2 =
+++ _mm_mul_ps(iValue, iValue); // Square the I values
+++ __VOLK_VOLATILE __m128 qValue2 =
+++ _mm_mul_ps(qValue, qValue); // Square the Q Values
++
++- result = _mm_add_ps(iValue2, qValue2); // Add the I2 and Q2 values
+++ result = _mm_add_ps(iValue2, qValue2); // Add the I2 and Q2 values
++
++- result = _mm_sqrt_ps(result);
+++ result = _mm_sqrt_ps(result);
++
++- result = _mm_mul_ps(result, vScalar);
+++ result = _mm_mul_ps(result, vScalar);
++
++- _mm_store_ps(floatBuffer, result);
++- *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[0]);
++- *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[1]);
++- *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[2]);
++- *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[3]);
++- }
+++ _mm_store_ps(floatBuffer, result);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[0]);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[1]);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[2]);
+++ *magnitudeVectorPtr++ = (int16_t)rintf(floatBuffer[3]);
+++ }
++
++- number = quarterPoints * 4;
++- volk_32fc_s32f_magnitude_16i_generic(magnitudeVector+number, complexVector+number, scalar, num_points-number);
+++ number = quarterPoints * 4;
+++ volk_32fc_s32f_magnitude_16i_generic(
+++ magnitudeVector + number, complexVector + number, scalar, num_points - number);
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -253,56 +263,59 @@ volk_32fc_s32f_magnitude_16i_a_sse(int16_t* magnitudeVector, const lv_32fc_t* co
++ #ifndef INCLUDED_volk_32fc_s32f_magnitude_16i_u_H
++ #define INCLUDED_volk_32fc_s32f_magnitude_16i_u_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_s32f_magnitude_16i_u_avx2(int16_t* magnitudeVector, const lv_32fc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32fc_s32f_magnitude_16i_u_avx2(int16_t* magnitudeVector,
+++ const lv_32fc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
++
++- const float* complexVectorPtr = (const float*)complexVector;
++- int16_t* magnitudeVectorPtr = magnitudeVector;
+++ const float* complexVectorPtr = (const float*)complexVector;
+++ int16_t* magnitudeVectorPtr = magnitudeVector;
++
++- __m256 vScalar = _mm256_set1_ps(scalar);
++- __m256i idx = _mm256_set_epi32(0,0,0,0,5,1,4,0);
++- __m256 cplxValue1, cplxValue2, result;
++- __m256i resultInt;
++- __m128i resultShort;
+++ __m256 vScalar = _mm256_set1_ps(scalar);
+++ __m256i idx = _mm256_set_epi32(0, 0, 0, 0, 5, 1, 4, 0);
+++ __m256 cplxValue1, cplxValue2, result;
+++ __m256i resultInt;
+++ __m128i resultShort;
++
++- for(;number < eighthPoints; number++){
++- cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ for (; number < eighthPoints; number++) {
+++ cplxValue1 = _mm256_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- cplxValue2 = _mm256_loadu_ps(complexVectorPtr);
++- complexVectorPtr += 8;
+++ cplxValue2 = _mm256_loadu_ps(complexVectorPtr);
+++ complexVectorPtr += 8;
++
++- cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
++- cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
+++ cplxValue1 = _mm256_mul_ps(cplxValue1, cplxValue1); // Square the values
+++ cplxValue2 = _mm256_mul_ps(cplxValue2, cplxValue2); // Square the Values
++
++- result = _mm256_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
+++ result = _mm256_hadd_ps(cplxValue1, cplxValue2); // Add the I2 and Q2 values
++
++- result = _mm256_sqrt_ps(result);
+++ result = _mm256_sqrt_ps(result);
++
++- result = _mm256_mul_ps(result, vScalar);
+++ result = _mm256_mul_ps(result, vScalar);
++
++- resultInt = _mm256_cvtps_epi32(result);
++- resultInt = _mm256_packs_epi32(resultInt, resultInt);
++- resultInt = _mm256_permutevar8x32_epi32(resultInt, idx); //permute to compensate for shuffling in hadd and packs
++- resultShort = _mm256_extracti128_si256(resultInt,0);
++- _mm_storeu_si128((__m128i*)magnitudeVectorPtr,resultShort);
++- magnitudeVectorPtr += 8;
++- }
+++ resultInt = _mm256_cvtps_epi32(result);
+++ resultInt = _mm256_packs_epi32(resultInt, resultInt);
+++ resultInt = _mm256_permutevar8x32_epi32(
+++ resultInt, idx); // permute to compensate for shuffling in hadd and packs
+++ resultShort = _mm256_extracti128_si256(resultInt, 0);
+++ _mm_storeu_si128((__m128i*)magnitudeVectorPtr, resultShort);
+++ magnitudeVectorPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- volk_32fc_s32f_magnitude_16i_generic(magnitudeVector+number, complexVector+number, scalar, num_points-number);
+++ number = eighthPoints * 8;
+++ volk_32fc_s32f_magnitude_16i_generic(
+++ magnitudeVector + number, complexVector + number, scalar, num_points - number);
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_32fc_s32f_power_32fc.h b/kernels/volk/volk_32fc_s32f_power_32fc.h
++index d2803f2..b31179c 100644
++--- a/kernels/volk/volk_32fc_s32f_power_32fc.h
+++++ b/kernels/volk/volk_32fc_s32f_power_32fc.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_s32f_power_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float power, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_s32f_power_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const
+++ * float power, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: The complex input vector.
++@@ -56,15 +56,17 @@
++ #define INCLUDED_volk_32fc_s32f_power_32fc_a_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++
++ //! raise a complex float to a real float power
++-static inline lv_32fc_t __volk_s32fc_s32f_power_s32fc_a(const lv_32fc_t exp, const float power)
+++static inline lv_32fc_t __volk_s32fc_s32f_power_s32fc_a(const lv_32fc_t exp,
+++ const float power)
++ {
++- const float arg = power*atan2f(lv_creal(exp), lv_cimag(exp));
++- const float mag = powf(lv_creal(exp)*lv_creal(exp) + lv_cimag(exp)*lv_cimag(exp), power/2);
++- return mag*lv_cmake(-cosf(arg), sinf(arg));
+++ const float arg = power * atan2f(lv_creal(exp), lv_cimag(exp));
+++ const float mag =
+++ powf(lv_creal(exp) * lv_creal(exp) + lv_cimag(exp) * lv_cimag(exp), power / 2);
+++ return mag * lv_cmake(-cosf(arg), sinf(arg));
++ }
++
++ #ifdef LV_HAVE_SSE
++@@ -74,83 +76,94 @@ static inline lv_32fc_t __volk_s32fc_s32f_power_s32fc_a(const lv_32fc_t exp, con
++ #include <simdmath.h>
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++
++-static inline void
++-volk_32fc_s32f_power_32fc_a_sse(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const float power, unsigned int num_points)
+++static inline void volk_32fc_s32f_power_32fc_a_sse(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const float power,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
+++ unsigned int number = 0;
++
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
++
++ #ifdef LV_HAVE_LIB_SIMDMATH
++- const unsigned int quarterPoints = num_points / 4;
++- __m128 vPower = _mm_set_ps1(power);
+++ const unsigned int quarterPoints = num_points / 4;
+++ __m128 vPower = _mm_set_ps1(power);
++
++- __m128 cplxValue1, cplxValue2, magnitude, phase, iValue, qValue;
++- for(;number < quarterPoints; number++){
+++ __m128 cplxValue1, cplxValue2, magnitude, phase, iValue, qValue;
+++ for (; number < quarterPoints; number++) {
++
++- cplxValue1 = _mm_load_ps((float*)aPtr);
++- aPtr += 2;
+++ cplxValue1 = _mm_load_ps((float*)aPtr);
+++ aPtr += 2;
++
++- cplxValue2 = _mm_load_ps((float*)aPtr);
++- aPtr += 2;
+++ cplxValue2 = _mm_load_ps((float*)aPtr);
+++ aPtr += 2;
++
++- // Convert to polar coordinates
+++ // Convert to polar coordinates
++
++- // Arrange in i1i2i3i4 format
++- iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
++- // Arrange in q1q2q3q4 format
++- qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
+++ // Arrange in q1q2q3q4 format
+++ qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3, 1, 3, 1));
++
++- phase = atan2f4(qValue, iValue); // Calculate the Phase
+++ phase = atan2f4(qValue, iValue); // Calculate the Phase
++
++- magnitude = _mm_sqrt_ps(_mm_add_ps(_mm_mul_ps(iValue, iValue), _mm_mul_ps(qValue, qValue))); // Calculate the magnitude by square rooting the added I2 and Q2 values
+++ magnitude = _mm_sqrt_ps(
+++ _mm_add_ps(_mm_mul_ps(iValue, iValue),
+++ _mm_mul_ps(qValue, qValue))); // Calculate the magnitude by square
+++ // rooting the added I2 and Q2 values
++
++- // Now calculate the power of the polar coordinate data
++- magnitude = powf4(magnitude, vPower); // Take the magnitude to the specified power
+++ // Now calculate the power of the polar coordinate data
+++ magnitude = powf4(magnitude, vPower); // Take the magnitude to the specified power
++
++- phase = _mm_mul_ps(phase, vPower); // Multiply the phase by the specified power
+++ phase = _mm_mul_ps(phase, vPower); // Multiply the phase by the specified power
++
++- // Convert back to cartesian coordinates
++- iValue = _mm_mul_ps( cosf4(phase), magnitude); // Multiply the cos of the phase by the magnitude
++- qValue = _mm_mul_ps( sinf4(phase), magnitude); // Multiply the sin of the phase by the magnitude
+++ // Convert back to cartesian coordinates
+++ iValue = _mm_mul_ps(cosf4(phase),
+++ magnitude); // Multiply the cos of the phase by the magnitude
+++ qValue = _mm_mul_ps(sinf4(phase),
+++ magnitude); // Multiply the sin of the phase by the magnitude
++
++- cplxValue1 = _mm_unpacklo_ps(iValue, qValue); // Interleave the lower two i & q values
++- cplxValue2 = _mm_unpackhi_ps(iValue, qValue); // Interleave the upper two i & q values
+++ cplxValue1 =
+++ _mm_unpacklo_ps(iValue, qValue); // Interleave the lower two i & q values
+++ cplxValue2 =
+++ _mm_unpackhi_ps(iValue, qValue); // Interleave the upper two i & q values
++
++- _mm_store_ps((float*)cPtr,cplxValue1); // Store the results back into the C container
+++ _mm_store_ps((float*)cPtr,
+++ cplxValue1); // Store the results back into the C container
++
++- cPtr += 2;
+++ cPtr += 2;
++
++- _mm_store_ps((float*)cPtr,cplxValue2); // Store the results back into the C container
+++ _mm_store_ps((float*)cPtr,
+++ cplxValue2); // Store the results back into the C container
++
++- cPtr += 2;
++- }
+++ cPtr += 2;
+++ }
++
++- number = quarterPoints * 4;
+++ number = quarterPoints * 4;
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++
++- for(;number < num_points; number++){
++- *cPtr++ = __volk_s32fc_s32f_power_s32fc_a((*aPtr++), power);
++- }
+++ for (; number < num_points; number++) {
+++ *cPtr++ = __volk_s32fc_s32f_power_s32fc_a((*aPtr++), power);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_s32f_power_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const float power, unsigned int num_points)
+++static inline void volk_32fc_s32f_power_32fc_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const float power,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- unsigned int number = 0;
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = __volk_s32fc_s32f_power_s32fc_a((*aPtr++), power);
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = __volk_s32fc_s32f_power_s32fc_a((*aPtr++), power);
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++diff --git a/kernels/volk/volk_32fc_s32f_power_spectrum_32f.h b/kernels/volk/volk_32fc_s32f_power_spectrum_32f.h
++index abe4662..a1a036d 100644
++--- a/kernels/volk/volk_32fc_s32f_power_spectrum_32f.h
+++++ b/kernels/volk/volk_32fc_s32f_power_spectrum_32f.h
++@@ -29,13 +29,13 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_s32f_power_spectrum_32f(float* logPowerOutput, const lv_32fc_t* complexFFTInput, const float normalizationFactor, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_s32f_power_spectrum_32f(float* logPowerOutput, const lv_32fc_t*
+++ * complexFFTInput, const float normalizationFactor, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexFFTInput The complex data output from the FFT point.
++- * \li normalizationFactor: This value is divided against all the input values before the power is calculated.
++- * \li num_points: The number of fft data points.
+++ * \li normalizationFactor: This value is divided against all the input values before the
+++ * power is calculated. \li num_points: The number of fft data points.
++ *
++ * \b Outputs
++ * \li logPowerOutput: The 10.0 * log10(r*r + i*i) for each data point.
++@@ -54,8 +54,8 @@
++ #define INCLUDED_volk_32fc_s32f_power_spectrum_32f_a_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_SSE3
++ #include <pmmintrin.h>
++@@ -65,74 +65,75 @@
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++
++ static inline void
++-volk_32fc_s32f_power_spectrum_32f_a_sse3(float* logPowerOutput, const lv_32fc_t* complexFFTInput,
++- const float normalizationFactor, unsigned int num_points)
+++volk_32fc_s32f_power_spectrum_32f_a_sse3(float* logPowerOutput,
+++ const lv_32fc_t* complexFFTInput,
+++ const float normalizationFactor,
+++ unsigned int num_points)
++ {
++- const float* inputPtr = (const float*)complexFFTInput;
++- float* destPtr = logPowerOutput;
++- uint64_t number = 0;
++- const float iNormalizationFactor = 1.0 / normalizationFactor;
+++ const float* inputPtr = (const float*)complexFFTInput;
+++ float* destPtr = logPowerOutput;
+++ uint64_t number = 0;
+++ const float iNormalizationFactor = 1.0 / normalizationFactor;
++ #ifdef LV_HAVE_LIB_SIMDMATH
++- __m128 magScalar = _mm_set_ps1(10.0);
++- magScalar = _mm_div_ps(magScalar, logf4(magScalar));
+++ __m128 magScalar = _mm_set_ps1(10.0);
+++ magScalar = _mm_div_ps(magScalar, logf4(magScalar));
++
++- __m128 invNormalizationFactor = _mm_set_ps1(iNormalizationFactor);
+++ __m128 invNormalizationFactor = _mm_set_ps1(iNormalizationFactor);
++
++- __m128 power;
++- __m128 input1, input2;
++- const uint64_t quarterPoints = num_points / 4;
++- for(;number < quarterPoints; number++){
++- // Load the complex values
++- input1 =_mm_load_ps(inputPtr);
++- inputPtr += 4;
++- input2 =_mm_load_ps(inputPtr);
++- inputPtr += 4;
+++ __m128 power;
+++ __m128 input1, input2;
+++ const uint64_t quarterPoints = num_points / 4;
+++ for (; number < quarterPoints; number++) {
+++ // Load the complex values
+++ input1 = _mm_load_ps(inputPtr);
+++ inputPtr += 4;
+++ input2 = _mm_load_ps(inputPtr);
+++ inputPtr += 4;
++
++- // Apply the normalization factor
++- input1 = _mm_mul_ps(input1, invNormalizationFactor);
++- input2 = _mm_mul_ps(input2, invNormalizationFactor);
+++ // Apply the normalization factor
+++ input1 = _mm_mul_ps(input1, invNormalizationFactor);
+++ input2 = _mm_mul_ps(input2, invNormalizationFactor);
++
++- // Multiply each value by itself
++- // (r1*r1), (i1*i1), (r2*r2), (i2*i2)
++- input1 = _mm_mul_ps(input1, input1);
++- // (r3*r3), (i3*i3), (r4*r4), (i4*i4)
++- input2 = _mm_mul_ps(input2, input2);
+++ // Multiply each value by itself
+++ // (r1*r1), (i1*i1), (r2*r2), (i2*i2)
+++ input1 = _mm_mul_ps(input1, input1);
+++ // (r3*r3), (i3*i3), (r4*r4), (i4*i4)
+++ input2 = _mm_mul_ps(input2, input2);
++
++- // Horizontal add, to add (r*r) + (i*i) for each complex value
++- // (r1*r1)+(i1*i1), (r2*r2) + (i2*i2), (r3*r3)+(i3*i3), (r4*r4)+(i4*i4)
++- power = _mm_hadd_ps(input1, input2);
+++ // Horizontal add, to add (r*r) + (i*i) for each complex value
+++ // (r1*r1)+(i1*i1), (r2*r2) + (i2*i2), (r3*r3)+(i3*i3), (r4*r4)+(i4*i4)
+++ power = _mm_hadd_ps(input1, input2);
++
++- // Calculate the natural log power
++- power = logf4(power);
+++ // Calculate the natural log power
+++ power = logf4(power);
++
++- // Convert to log10 and multiply by 10.0
++- power = _mm_mul_ps(power, magScalar);
+++ // Convert to log10 and multiply by 10.0
+++ power = _mm_mul_ps(power, magScalar);
++
++- // Store the floating point results
++- _mm_store_ps(destPtr, power);
+++ // Store the floating point results
+++ _mm_store_ps(destPtr, power);
++
++- destPtr += 4;
++- }
+++ destPtr += 4;
+++ }
++
++- number = quarterPoints*4;
+++ number = quarterPoints * 4;
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++- // Calculate the FFT for any remaining points
++-
++- for(; number < num_points; number++){
++- // Calculate dBm
++- // 50 ohm load assumption
++- // 10 * log10 (v^2 / (2 * 50.0 * .001)) = 10 * log10( v^2 * 10)
++- // 75 ohm load assumption
++- // 10 * log10 (v^2 / (2 * 75.0 * .001)) = 10 * log10( v^2 * 15)
+++ // Calculate the FFT for any remaining points
++
++- const float real = *inputPtr++ * iNormalizationFactor;
++- const float imag = *inputPtr++ * iNormalizationFactor;
+++ for (; number < num_points; number++) {
+++ // Calculate dBm
+++ // 50 ohm load assumption
+++ // 10 * log10 (v^2 / (2 * 50.0 * .001)) = 10 * log10( v^2 * 10)
+++ // 75 ohm load assumption
+++ // 10 * log10 (v^2 / (2 * 75.0 * .001)) = 10 * log10( v^2 * 15)
++
++- *destPtr = 10.0*log10f(((real * real) + (imag * imag)) + 1e-20);
+++ const float real = *inputPtr++ * iNormalizationFactor;
+++ const float imag = *inputPtr++ * iNormalizationFactor;
++
++- destPtr++;
++- }
+++ *destPtr = 10.0 * log10f(((real * real) + (imag * imag)) + 1e-20);
++
+++ destPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE3 */
++
++@@ -141,7 +142,10 @@ volk_32fc_s32f_power_spectrum_32f_a_sse3(float* logPowerOutput, const lv_32fc_t*
++ #include <volk/volk_neon_intrinsics.h>
++
++ static inline void
++-volk_32fc_s32f_power_spectrum_32f_neon(float* logPowerOutput, const lv_32fc_t* complexFFTInput, const float normalizationFactor, unsigned int num_points)
+++volk_32fc_s32f_power_spectrum_32f_neon(float* logPowerOutput,
+++ const lv_32fc_t* complexFFTInput,
+++ const float normalizationFactor,
+++ unsigned int num_points)
++ {
++ float* logPowerOutputPtr = logPowerOutput;
++ const lv_32fc_t* complexFFTInputPtr = complexFFTInput;
++@@ -151,14 +155,14 @@ volk_32fc_s32f_power_spectrum_32f_neon(float* logPowerOutput, const lv_32fc_t* c
++ float32x4x2_t fft_vec;
++ float32x4_t log_pwr_vec;
++ float32x4_t mag_squared_vec;
++-
+++
++ const float inv_ln10_10 = 4.34294481903f; // 10.0/ln(10.)
++-
++- for(number = 0; number < quarter_points; number++) {
+++
+++ for (number = 0; number < quarter_points; number++) {
++ // Load
++ fft_vec = vld2q_f32((float*)complexFFTInputPtr);
++ // Prefetch next 4
++- __VOLK_PREFETCH(complexFFTInputPtr+4);
+++ __VOLK_PREFETCH(complexFFTInputPtr + 4);
++ // Normalize
++ fft_vec.val[0] = vmulq_n_f32(fft_vec.val[0], iNormalizationFactor);
++ fft_vec.val[1] = vmulq_n_f32(fft_vec.val[1], iNormalizationFactor);
++@@ -167,12 +171,12 @@ volk_32fc_s32f_power_spectrum_32f_neon(float* logPowerOutput, const lv_32fc_t* c
++ // Store
++ vst1q_f32(logPowerOutputPtr, log_pwr_vec);
++ // Move pointers ahead
++- complexFFTInputPtr+=4;
++- logPowerOutputPtr+=4;
+++ complexFFTInputPtr += 4;
+++ logPowerOutputPtr += 4;
++ }
++-
+++
++ // deal with the rest
++- for(number = quarter_points * 4; number < num_points; number++) {
+++ for (number = quarter_points * 4; number < num_points; number++) {
++ const float real = lv_creal(*complexFFTInputPtr) * iNormalizationFactor;
++ const float imag = lv_cimag(*complexFFTInputPtr) * iNormalizationFactor;
++ *logPowerOutputPtr = 10.0 * log10f(((real * real) + (imag * imag)) + 1e-20);
++@@ -186,27 +190,29 @@ volk_32fc_s32f_power_spectrum_32f_neon(float* logPowerOutput, const lv_32fc_t* c
++ #ifdef LV_HAVE_GENERIC
++
++ static inline void
++-volk_32fc_s32f_power_spectrum_32f_generic(float* logPowerOutput, const lv_32fc_t* complexFFTInput,
++- const float normalizationFactor, unsigned int num_points)
+++volk_32fc_s32f_power_spectrum_32f_generic(float* logPowerOutput,
+++ const lv_32fc_t* complexFFTInput,
+++ const float normalizationFactor,
+++ unsigned int num_points)
++ {
++- // Calculate the Power of the complex point
++- const float* inputPtr = (float*)complexFFTInput;
++- float* realFFTDataPointsPtr = logPowerOutput;
++- const float iNormalizationFactor = 1.0 / normalizationFactor;
++- unsigned int point;
++- for(point = 0; point < num_points; point++){
++- // Calculate dBm
++- // 50 ohm load assumption
++- // 10 * log10 (v^2 / (2 * 50.0 * .001)) = 10 * log10( v^2 * 10)
++- // 75 ohm load assumption
++- // 10 * log10 (v^2 / (2 * 75.0 * .001)) = 10 * log10( v^2 * 15)
++-
++- const float real = *inputPtr++ * iNormalizationFactor;
++- const float imag = *inputPtr++ * iNormalizationFactor;
++-
++- *realFFTDataPointsPtr = 10.0*log10f(((real * real) + (imag * imag)) + 1e-20);
++- realFFTDataPointsPtr++;
++- }
+++ // Calculate the Power of the complex point
+++ const float* inputPtr = (float*)complexFFTInput;
+++ float* realFFTDataPointsPtr = logPowerOutput;
+++ const float iNormalizationFactor = 1.0 / normalizationFactor;
+++ unsigned int point;
+++ for (point = 0; point < num_points; point++) {
+++ // Calculate dBm
+++ // 50 ohm load assumption
+++ // 10 * log10 (v^2 / (2 * 50.0 * .001)) = 10 * log10( v^2 * 10)
+++ // 75 ohm load assumption
+++ // 10 * log10 (v^2 / (2 * 75.0 * .001)) = 10 * log10( v^2 * 15)
+++
+++ const float real = *inputPtr++ * iNormalizationFactor;
+++ const float imag = *inputPtr++ * iNormalizationFactor;
+++
+++ *realFFTDataPointsPtr = 10.0 * log10f(((real * real) + (imag * imag)) + 1e-20);
+++ realFFTDataPointsPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32fc_s32f_x2_power_spectral_density_32f.h b/kernels/volk/volk_32fc_s32f_x2_power_spectral_density_32f.h
++index 3260b08..37ca43c 100644
++--- a/kernels/volk/volk_32fc_s32f_x2_power_spectral_density_32f.h
+++++ b/kernels/volk/volk_32fc_s32f_x2_power_spectral_density_32f.h
++@@ -29,14 +29,15 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_s32f_x2_power_spectral_density_32f(float* logPowerOutput, const lv_32fc_t* complexFFTInput, const float normalizationFactor, const float rbw, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_s32f_x2_power_spectral_density_32f(float* logPowerOutput, const
+++ * lv_32fc_t* complexFFTInput, const float normalizationFactor, const float rbw, unsigned
+++ * int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexFFTInput The complex data output from the FFT point.
++- * \li normalizationFactor: This value is divided against all the input values before the power is calculated.
++- * \li rbw: The resolution bandwidth of the fft spectrum
++- * \li num_points: The number of fft data points.
+++ * \li normalizationFactor: This value is divided against all the input values before the
+++ * power is calculated. \li rbw: The resolution bandwidth of the fft spectrum \li
+++ * num_points: The number of fft data points.
++ *
++ * \b Outputs
++ * \li logPowerOutput: The 10.0 * log10((r*r + i*i)/RBW) for each data point.
++@@ -55,8 +56,8 @@
++ #define INCLUDED_volk_32fc_s32f_x2_power_spectral_density_32f_a_H
++
++ #include <inttypes.h>
++-#include <stdio.h>
++ #include <math.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++@@ -66,83 +67,84 @@
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++
++ static inline void
++-volk_32fc_s32f_x2_power_spectral_density_32f_a_avx(float* logPowerOutput, const lv_32fc_t* complexFFTInput,
++- const float normalizationFactor, const float rbw,
+++volk_32fc_s32f_x2_power_spectral_density_32f_a_avx(float* logPowerOutput,
+++ const lv_32fc_t* complexFFTInput,
+++ const float normalizationFactor,
+++ const float rbw,
++ unsigned int num_points)
++ {
++- const float* inputPtr = (const float*)complexFFTInput;
++- float* destPtr = logPowerOutput;
++- uint64_t number = 0;
++- const float iRBW = 1.0 / rbw;
++- const float iNormalizationFactor = 1.0 / normalizationFactor;
+++ const float* inputPtr = (const float*)complexFFTInput;
+++ float* destPtr = logPowerOutput;
+++ uint64_t number = 0;
+++ const float iRBW = 1.0 / rbw;
+++ const float iNormalizationFactor = 1.0 / normalizationFactor;
++
++ #ifdef LV_HAVE_LIB_SIMDMATH
++- __m256 magScalar = _mm256_set1_ps(10.0);
++- magScalar = _mm256_div_ps(magScalar, logf4(magScalar));
+++ __m256 magScalar = _mm256_set1_ps(10.0);
+++ magScalar = _mm256_div_ps(magScalar, logf4(magScalar));
++
++- __m256 invRBW = _mm256_set1_ps(iRBW);
+++ __m256 invRBW = _mm256_set1_ps(iRBW);
++
++- __m256 invNormalizationFactor = _mm256_set1_ps(iNormalizationFactor);
+++ __m256 invNormalizationFactor = _mm256_set1_ps(iNormalizationFactor);
++
++- __m256 power;
++- __m256 input1, input2;
++- const uint64_t eighthPoints = num_points / 8;
++- for(;number < eighthPoints; number++){
++- // Load the complex values
++- input1 =_mm256_load_ps(inputPtr);
++- inputPtr += 8;
++- input2 =_mm256_load_ps(inputPtr);
++- inputPtr += 8;
+++ __m256 power;
+++ __m256 input1, input2;
+++ const uint64_t eighthPoints = num_points / 8;
+++ for (; number < eighthPoints; number++) {
+++ // Load the complex values
+++ input1 = _mm256_load_ps(inputPtr);
+++ inputPtr += 8;
+++ input2 = _mm256_load_ps(inputPtr);
+++ inputPtr += 8;
++
++- // Apply the normalization factor
++- input1 = _mm256_mul_ps(input1, invNormalizationFactor);
++- input2 = _mm256_mul_ps(input2, invNormalizationFactor);
+++ // Apply the normalization factor
+++ input1 = _mm256_mul_ps(input1, invNormalizationFactor);
+++ input2 = _mm256_mul_ps(input2, invNormalizationFactor);
++
++- // Multiply each value by itself
++- // (r1*r1), (i1*i1), (r2*r2), (i2*i2)
++- input1 = _mm256_mul_ps(input1, input1);
++- // (r3*r3), (i3*i3), (r4*r4), (i4*i4)
++- input2 = _mm256_mul_ps(input2, input2);
+++ // Multiply each value by itself
+++ // (r1*r1), (i1*i1), (r2*r2), (i2*i2)
+++ input1 = _mm256_mul_ps(input1, input1);
+++ // (r3*r3), (i3*i3), (r4*r4), (i4*i4)
+++ input2 = _mm256_mul_ps(input2, input2);
++
++- // Horizontal add, to add (r*r) + (i*i) for each complex value
++- // (r1*r1)+(i1*i1), (r2*r2) + (i2*i2), (r3*r3)+(i3*i3), (r4*r4)+(i4*i4)
++- inputVal1 = _mm256_permute2f128_ps(input1, input2, 0x20);
++- inputVal2 = _mm256_permute2f128_ps(input1, input2, 0x31);
+++ // Horizontal add, to add (r*r) + (i*i) for each complex value
+++ // (r1*r1)+(i1*i1), (r2*r2) + (i2*i2), (r3*r3)+(i3*i3), (r4*r4)+(i4*i4)
+++ inputVal1 = _mm256_permute2f128_ps(input1, input2, 0x20);
+++ inputVal2 = _mm256_permute2f128_ps(input1, input2, 0x31);
++
++- power = _mm256_hadd_ps(inputVal1, inputVal2);
+++ power = _mm256_hadd_ps(inputVal1, inputVal2);
++
++- // Divide by the rbw
++- power = _mm256_mul_ps(power, invRBW);
+++ // Divide by the rbw
+++ power = _mm256_mul_ps(power, invRBW);
++
++- // Calculate the natural log power
++- power = logf4(power);
+++ // Calculate the natural log power
+++ power = logf4(power);
++
++- // Convert to log10 and multiply by 10.0
++- power = _mm256_mul_ps(power, magScalar);
+++ // Convert to log10 and multiply by 10.0
+++ power = _mm256_mul_ps(power, magScalar);
++
++- // Store the floating point results
++- _mm256_store_ps(destPtr, power);
+++ // Store the floating point results
+++ _mm256_store_ps(destPtr, power);
++
++- destPtr += 8;
++- }
+++ destPtr += 8;
+++ }
++
++- number = eighthPoints*8;
+++ number = eighthPoints * 8;
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++- // Calculate the FFT for any remaining points
++- for(; number < num_points; number++){
++- // Calculate dBm
++- // 50 ohm load assumption
++- // 10 * log10 (v^2 / (2 * 50.0 * .001)) = 10 * log10( v^2 * 10)
++- // 75 ohm load assumption
++- // 10 * log10 (v^2 / (2 * 75.0 * .001)) = 10 * log10( v^2 * 15)
++-
++- const float real = *inputPtr++ * iNormalizationFactor;
++- const float imag = *inputPtr++ * iNormalizationFactor;
++-
++- *destPtr = 10.0*log10f((((real * real) + (imag * imag)) + 1e-20) * iRBW);
++- destPtr++;
++- }
++-
+++ // Calculate the FFT for any remaining points
+++ for (; number < num_points; number++) {
+++ // Calculate dBm
+++ // 50 ohm load assumption
+++ // 10 * log10 (v^2 / (2 * 50.0 * .001)) = 10 * log10( v^2 * 10)
+++ // 75 ohm load assumption
+++ // 10 * log10 (v^2 / (2 * 75.0 * .001)) = 10 * log10( v^2 * 15)
+++
+++ const float real = *inputPtr++ * iNormalizationFactor;
+++ const float imag = *inputPtr++ * iNormalizationFactor;
+++
+++ *destPtr = 10.0 * log10f((((real * real) + (imag * imag)) + 1e-20) * iRBW);
+++ destPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -150,86 +152,86 @@ volk_32fc_s32f_x2_power_spectral_density_32f_a_avx(float* logPowerOutput, const
++ #include <pmmintrin.h>
++
++
++-
++ #ifdef LV_HAVE_LIB_SIMDMATH
++ #include <simdmath.h>
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++
++ static inline void
++-volk_32fc_s32f_x2_power_spectral_density_32f_a_sse3(float* logPowerOutput, const lv_32fc_t* complexFFTInput,
++- const float normalizationFactor, const float rbw,
+++volk_32fc_s32f_x2_power_spectral_density_32f_a_sse3(float* logPowerOutput,
+++ const lv_32fc_t* complexFFTInput,
+++ const float normalizationFactor,
+++ const float rbw,
++ unsigned int num_points)
++ {
++- const float* inputPtr = (const float*)complexFFTInput;
++- float* destPtr = logPowerOutput;
++- uint64_t number = 0;
++- const float iRBW = 1.0 / rbw;
++- const float iNormalizationFactor = 1.0 / normalizationFactor;
+++ const float* inputPtr = (const float*)complexFFTInput;
+++ float* destPtr = logPowerOutput;
+++ uint64_t number = 0;
+++ const float iRBW = 1.0 / rbw;
+++ const float iNormalizationFactor = 1.0 / normalizationFactor;
++
++ #ifdef LV_HAVE_LIB_SIMDMATH
++- __m128 magScalar = _mm_set_ps1(10.0);
++- magScalar = _mm_div_ps(magScalar, logf4(magScalar));
+++ __m128 magScalar = _mm_set_ps1(10.0);
+++ magScalar = _mm_div_ps(magScalar, logf4(magScalar));
++
++- __m128 invRBW = _mm_set_ps1(iRBW);
+++ __m128 invRBW = _mm_set_ps1(iRBW);
++
++- __m128 invNormalizationFactor = _mm_set_ps1(iNormalizationFactor);
+++ __m128 invNormalizationFactor = _mm_set_ps1(iNormalizationFactor);
++
++- __m128 power;
++- __m128 input1, input2;
++- const uint64_t quarterPoints = num_points / 4;
++- for(;number < quarterPoints; number++){
++- // Load the complex values
++- input1 =_mm_load_ps(inputPtr);
++- inputPtr += 4;
++- input2 =_mm_load_ps(inputPtr);
++- inputPtr += 4;
+++ __m128 power;
+++ __m128 input1, input2;
+++ const uint64_t quarterPoints = num_points / 4;
+++ for (; number < quarterPoints; number++) {
+++ // Load the complex values
+++ input1 = _mm_load_ps(inputPtr);
+++ inputPtr += 4;
+++ input2 = _mm_load_ps(inputPtr);
+++ inputPtr += 4;
++
++- // Apply the normalization factor
++- input1 = _mm_mul_ps(input1, invNormalizationFactor);
++- input2 = _mm_mul_ps(input2, invNormalizationFactor);
+++ // Apply the normalization factor
+++ input1 = _mm_mul_ps(input1, invNormalizationFactor);
+++ input2 = _mm_mul_ps(input2, invNormalizationFactor);
++
++- // Multiply each value by itself
++- // (r1*r1), (i1*i1), (r2*r2), (i2*i2)
++- input1 = _mm_mul_ps(input1, input1);
++- // (r3*r3), (i3*i3), (r4*r4), (i4*i4)
++- input2 = _mm_mul_ps(input2, input2);
+++ // Multiply each value by itself
+++ // (r1*r1), (i1*i1), (r2*r2), (i2*i2)
+++ input1 = _mm_mul_ps(input1, input1);
+++ // (r3*r3), (i3*i3), (r4*r4), (i4*i4)
+++ input2 = _mm_mul_ps(input2, input2);
++
++- // Horizontal add, to add (r*r) + (i*i) for each complex value
++- // (r1*r1)+(i1*i1), (r2*r2) + (i2*i2), (r3*r3)+(i3*i3), (r4*r4)+(i4*i4)
++- power = _mm_hadd_ps(input1, input2);
+++ // Horizontal add, to add (r*r) + (i*i) for each complex value
+++ // (r1*r1)+(i1*i1), (r2*r2) + (i2*i2), (r3*r3)+(i3*i3), (r4*r4)+(i4*i4)
+++ power = _mm_hadd_ps(input1, input2);
++
++- // Divide by the rbw
++- power = _mm_mul_ps(power, invRBW);
+++ // Divide by the rbw
+++ power = _mm_mul_ps(power, invRBW);
++
++- // Calculate the natural log power
++- power = logf4(power);
+++ // Calculate the natural log power
+++ power = logf4(power);
++
++- // Convert to log10 and multiply by 10.0
++- power = _mm_mul_ps(power, magScalar);
+++ // Convert to log10 and multiply by 10.0
+++ power = _mm_mul_ps(power, magScalar);
++
++- // Store the floating point results
++- _mm_store_ps(destPtr, power);
+++ // Store the floating point results
+++ _mm_store_ps(destPtr, power);
++
++- destPtr += 4;
++- }
+++ destPtr += 4;
+++ }
++
++- number = quarterPoints*4;
+++ number = quarterPoints * 4;
++ #endif /* LV_HAVE_LIB_SIMDMATH */
++- // Calculate the FFT for any remaining points
++- for(; number < num_points; number++){
++- // Calculate dBm
++- // 50 ohm load assumption
++- // 10 * log10 (v^2 / (2 * 50.0 * .001)) = 10 * log10( v^2 * 10)
++- // 75 ohm load assumption
++- // 10 * log10 (v^2 / (2 * 75.0 * .001)) = 10 * log10( v^2 * 15)
++-
++- const float real = *inputPtr++ * iNormalizationFactor;
++- const float imag = *inputPtr++ * iNormalizationFactor;
++-
++- *destPtr = 10.0*log10f((((real * real) + (imag * imag)) + 1e-20) * iRBW);
++- destPtr++;
++- }
++-
+++ // Calculate the FFT for any remaining points
+++ for (; number < num_points; number++) {
+++ // Calculate dBm
+++ // 50 ohm load assumption
+++ // 10 * log10 (v^2 / (2 * 50.0 * .001)) = 10 * log10( v^2 * 10)
+++ // 75 ohm load assumption
+++ // 10 * log10 (v^2 / (2 * 75.0 * .001)) = 10 * log10( v^2 * 15)
+++
+++ const float real = *inputPtr++ * iNormalizationFactor;
+++ const float imag = *inputPtr++ * iNormalizationFactor;
+++
+++ *destPtr = 10.0 * log10f((((real * real) + (imag * imag)) + 1e-20) * iRBW);
+++ destPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE3 */
++
++@@ -237,31 +239,34 @@ volk_32fc_s32f_x2_power_spectral_density_32f_a_sse3(float* logPowerOutput, const
++ #ifdef LV_HAVE_GENERIC
++
++ static inline void
++-volk_32fc_s32f_x2_power_spectral_density_32f_generic(float* logPowerOutput, const lv_32fc_t* complexFFTInput,
++- const float normalizationFactor, const float rbw,
+++volk_32fc_s32f_x2_power_spectral_density_32f_generic(float* logPowerOutput,
+++ const lv_32fc_t* complexFFTInput,
+++ const float normalizationFactor,
+++ const float rbw,
++ unsigned int num_points)
++ {
++- // Calculate the Power of the complex point
++- const float* inputPtr = (float*)complexFFTInput;
++- float* realFFTDataPointsPtr = logPowerOutput;
++- unsigned int point;
++- const float invRBW = 1.0 / rbw;
++- const float iNormalizationFactor = 1.0 / normalizationFactor;
++-
++- for(point = 0; point < num_points; point++){
++- // Calculate dBm
++- // 50 ohm load assumption
++- // 10 * log10 (v^2 / (2 * 50.0 * .001)) = 10 * log10( v^2 * 10)
++- // 75 ohm load assumption
++- // 10 * log10 (v^2 / (2 * 75.0 * .001)) = 10 * log10( v^2 * 15)
++-
++- const float real = *inputPtr++ * iNormalizationFactor;
++- const float imag = *inputPtr++ * iNormalizationFactor;
++-
++- *realFFTDataPointsPtr = 10.0*log10f((((real * real) + (imag * imag)) + 1e-20) * invRBW);
++-
++- realFFTDataPointsPtr++;
++- }
+++ // Calculate the Power of the complex point
+++ const float* inputPtr = (float*)complexFFTInput;
+++ float* realFFTDataPointsPtr = logPowerOutput;
+++ unsigned int point;
+++ const float invRBW = 1.0 / rbw;
+++ const float iNormalizationFactor = 1.0 / normalizationFactor;
+++
+++ for (point = 0; point < num_points; point++) {
+++ // Calculate dBm
+++ // 50 ohm load assumption
+++ // 10 * log10 (v^2 / (2 * 50.0 * .001)) = 10 * log10( v^2 * 10)
+++ // 75 ohm load assumption
+++ // 10 * log10 (v^2 / (2 * 75.0 * .001)) = 10 * log10( v^2 * 15)
+++
+++ const float real = *inputPtr++ * iNormalizationFactor;
+++ const float imag = *inputPtr++ * iNormalizationFactor;
+++
+++ *realFFTDataPointsPtr =
+++ 10.0 * log10f((((real * real) + (imag * imag)) + 1e-20) * invRBW);
+++
+++ realFFTDataPointsPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32fc_s32fc_multiply_32fc.h b/kernels/volk/volk_32fc_s32fc_multiply_32fc.h
++index fe416b4..840008a 100644
++--- a/kernels/volk/volk_32fc_s32fc_multiply_32fc.h
+++++ b/kernels/volk/volk_32fc_s32fc_multiply_32fc.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_s32fc_multiply_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t scalar, unsigned int num_points);
++- * \endcode
+++ * void volk_32fc_s32fc_multiply_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const
+++ * lv_32fc_t scalar, unsigned int num_points); \endcode
++ *
++ * \b Inputs
++ * \li aVector: The input vector to be multiplied.
++@@ -76,15 +76,19 @@
++ #ifndef INCLUDED_volk_32fc_s32fc_multiply_32fc_u_H
++ #define INCLUDED_volk_32fc_s32fc_multiply_32fc_u_H
++
+++#include <float.h>
++ #include <inttypes.h>
++ #include <stdio.h>
++ #include <volk/volk_complex.h>
++-#include <float.h>
++
++ #if LV_HAVE_AVX && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void volk_32fc_s32fc_multiply_32fc_u_avx_fma(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t scalar, unsigned int num_points){
+++static inline void volk_32fc_s32fc_multiply_32fc_u_avx_fma(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
++ unsigned int number = 0;
++ unsigned int i = 0;
++ const unsigned int quarterPoints = num_points / 4;
++@@ -97,34 +101,38 @@ static inline void volk_32fc_s32fc_multiply_32fc_u_avx_fma(lv_32fc_t* cVector, c
++ yl = _mm256_set1_ps(lv_creal(scalar));
++ yh = _mm256_set1_ps(lv_cimag(scalar));
++
++- for(;number < quarterPoints; number++){
++- x = _mm256_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ for (; number < quarterPoints; number++) {
+++ x = _mm256_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
++
++- tmp1 = x;
+++ tmp1 = x;
++
++- x = _mm256_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br
+++ x = _mm256_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br
++
++- tmp2 = _mm256_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+++ tmp2 = _mm256_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
++
++- z = _mm256_fmaddsub_ps(tmp1, yl,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ z = _mm256_fmaddsub_ps(
+++ tmp1, yl, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- _mm256_storeu_ps((float*)c,z); // Store the results back into the C container
+++ _mm256_storeu_ps((float*)c, z); // Store the results back into the C container
++
++- a += 4;
++- c += 4;
+++ a += 4;
+++ c += 4;
++ }
++
++- for(i = num_points-isodd; i < num_points; i++) {
+++ for (i = num_points - isodd; i < num_points; i++) {
++ *c++ = (*a++) * scalar;
++ }
++-
++ }
++ #endif /* LV_HAVE_AVX && LV_HAVE_FMA */
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32fc_s32fc_multiply_32fc_u_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t scalar, unsigned int num_points){
+++static inline void volk_32fc_s32fc_multiply_32fc_u_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
++ unsigned int number = 0;
++ unsigned int i = 0;
++ const unsigned int quarterPoints = num_points / 4;
++@@ -137,35 +145,39 @@ static inline void volk_32fc_s32fc_multiply_32fc_u_avx(lv_32fc_t* cVector, const
++ yl = _mm256_set1_ps(lv_creal(scalar));
++ yh = _mm256_set1_ps(lv_cimag(scalar));
++
++- for(;number < quarterPoints; number++){
++- x = _mm256_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ for (; number < quarterPoints; number++) {
+++ x = _mm256_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
++
++- tmp1 = _mm256_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+++ tmp1 = _mm256_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
++
++- x = _mm256_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br
+++ x = _mm256_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br
++
++- tmp2 = _mm256_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+++ tmp2 = _mm256_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
++
++- z = _mm256_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ z = _mm256_addsub_ps(tmp1,
+++ tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- _mm256_storeu_ps((float*)c,z); // Store the results back into the C container
+++ _mm256_storeu_ps((float*)c, z); // Store the results back into the C container
++
++- a += 4;
++- c += 4;
+++ a += 4;
+++ c += 4;
++ }
++
++- for(i = num_points-isodd; i < num_points; i++) {
+++ for (i = num_points - isodd; i < num_points; i++) {
++ *c++ = (*a++) * scalar;
++ }
++-
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE3
++ #include <pmmintrin.h>
++
++-static inline void volk_32fc_s32fc_multiply_32fc_u_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t scalar, unsigned int num_points){
++- unsigned int number = 0;
+++static inline void volk_32fc_s32fc_multiply_32fc_u_sse3(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
++ const unsigned int halfPoints = num_points / 2;
++
++ __m128 x, yl, yh, z, tmp1, tmp2;
++@@ -176,53 +188,58 @@ static inline void volk_32fc_s32fc_multiply_32fc_u_sse3(lv_32fc_t* cVector, cons
++ yl = _mm_set_ps1(lv_creal(scalar));
++ yh = _mm_set_ps1(lv_cimag(scalar));
++
++- for(;number < halfPoints; number++){
+++ for (; number < halfPoints; number++) {
++
++- x = _mm_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ x = _mm_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
++
++- tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+++ tmp1 = _mm_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
++
++- x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br
+++ x = _mm_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br
++
++- tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+++ tmp2 = _mm_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
++
++- z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ z = _mm_addsub_ps(tmp1,
+++ tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- _mm_storeu_ps((float*)c,z); // Store the results back into the C container
+++ _mm_storeu_ps((float*)c, z); // Store the results back into the C container
++
++- a += 2;
++- c += 2;
+++ a += 2;
+++ c += 2;
++ }
++
++- if((num_points % 2) != 0) {
++- *c = (*a) * scalar;
+++ if ((num_points % 2) != 0) {
+++ *c = (*a) * scalar;
++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32fc_s32fc_multiply_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t scalar, unsigned int num_points){
+++static inline void volk_32fc_s32fc_multiply_32fc_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
++ lv_32fc_t* cPtr = cVector;
++ const lv_32fc_t* aPtr = aVector;
++ unsigned int number = num_points;
++
++ // unwrap loop
++- while (number >= 8){
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- number -= 8;
+++ while (number >= 8) {
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ number -= 8;
++ }
++
++ // clean up any remaining
++ while (number-- > 0)
++- *cPtr++ = *aPtr++ * scalar;
+++ *cPtr++ = *aPtr++ * scalar;
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -231,15 +248,19 @@ static inline void volk_32fc_s32fc_multiply_32fc_generic(lv_32fc_t* cVector, con
++ #ifndef INCLUDED_volk_32fc_s32fc_multiply_32fc_a_H
++ #define INCLUDED_volk_32fc_s32fc_multiply_32fc_a_H
++
+++#include <float.h>
++ #include <inttypes.h>
++ #include <stdio.h>
++ #include <volk/volk_complex.h>
++-#include <float.h>
++
++ #if LV_HAVE_AVX && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void volk_32fc_s32fc_multiply_32fc_a_avx_fma(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t scalar, unsigned int num_points){
+++static inline void volk_32fc_s32fc_multiply_32fc_a_avx_fma(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
++ unsigned int number = 0;
++ unsigned int i = 0;
++ const unsigned int quarterPoints = num_points / 4;
++@@ -252,27 +273,27 @@ static inline void volk_32fc_s32fc_multiply_32fc_a_avx_fma(lv_32fc_t* cVector, c
++ yl = _mm256_set1_ps(lv_creal(scalar));
++ yh = _mm256_set1_ps(lv_cimag(scalar));
++
++- for(;number < quarterPoints; number++){
++- x = _mm256_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ for (; number < quarterPoints; number++) {
+++ x = _mm256_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
++
++- tmp1 = x;
+++ tmp1 = x;
++
++- x = _mm256_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br
+++ x = _mm256_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br
++
++- tmp2 = _mm256_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+++ tmp2 = _mm256_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
++
++- z = _mm256_fmaddsub_ps(tmp1, yl,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ z = _mm256_fmaddsub_ps(
+++ tmp1, yl, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- _mm256_store_ps((float*)c,z); // Store the results back into the C container
+++ _mm256_store_ps((float*)c, z); // Store the results back into the C container
++
++- a += 4;
++- c += 4;
+++ a += 4;
+++ c += 4;
++ }
++
++- for(i = num_points-isodd; i < num_points; i++) {
+++ for (i = num_points - isodd; i < num_points; i++) {
++ *c++ = (*a++) * scalar;
++ }
++-
++ }
++ #endif /* LV_HAVE_AVX && LV_HAVE_FMA */
++
++@@ -280,7 +301,11 @@ static inline void volk_32fc_s32fc_multiply_32fc_a_avx_fma(lv_32fc_t* cVector, c
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32fc_s32fc_multiply_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t scalar, unsigned int num_points){
+++static inline void volk_32fc_s32fc_multiply_32fc_a_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
++ unsigned int number = 0;
++ unsigned int i = 0;
++ const unsigned int quarterPoints = num_points / 4;
++@@ -293,35 +318,39 @@ static inline void volk_32fc_s32fc_multiply_32fc_a_avx(lv_32fc_t* cVector, const
++ yl = _mm256_set1_ps(lv_creal(scalar));
++ yh = _mm256_set1_ps(lv_cimag(scalar));
++
++- for(;number < quarterPoints; number++){
++- x = _mm256_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ for (; number < quarterPoints; number++) {
+++ x = _mm256_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
++
++- tmp1 = _mm256_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+++ tmp1 = _mm256_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
++
++- x = _mm256_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br
+++ x = _mm256_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br
++
++- tmp2 = _mm256_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+++ tmp2 = _mm256_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
++
++- z = _mm256_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ z = _mm256_addsub_ps(tmp1,
+++ tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- _mm256_store_ps((float*)c,z); // Store the results back into the C container
+++ _mm256_store_ps((float*)c, z); // Store the results back into the C container
++
++- a += 4;
++- c += 4;
+++ a += 4;
+++ c += 4;
++ }
++
++- for(i = num_points-isodd; i < num_points; i++) {
+++ for (i = num_points - isodd; i < num_points; i++) {
++ *c++ = (*a++) * scalar;
++ }
++-
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE3
++ #include <pmmintrin.h>
++
++-static inline void volk_32fc_s32fc_multiply_32fc_a_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t scalar, unsigned int num_points){
++- unsigned int number = 0;
+++static inline void volk_32fc_s32fc_multiply_32fc_a_sse3(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
++ const unsigned int halfPoints = num_points / 2;
++
++ __m128 x, yl, yh, z, tmp1, tmp2;
++@@ -332,26 +361,27 @@ static inline void volk_32fc_s32fc_multiply_32fc_a_sse3(lv_32fc_t* cVector, cons
++ yl = _mm_set_ps1(lv_creal(scalar));
++ yh = _mm_set_ps1(lv_cimag(scalar));
++
++- for(;number < halfPoints; number++){
+++ for (; number < halfPoints; number++) {
++
++- x = _mm_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ x = _mm_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
++
++- tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+++ tmp1 = _mm_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
++
++- x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br
+++ x = _mm_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br
++
++- tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+++ tmp2 = _mm_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
++
++- z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ z = _mm_addsub_ps(tmp1,
+++ tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- _mm_store_ps((float*)c,z); // Store the results back into the C container
+++ _mm_store_ps((float*)c, z); // Store the results back into the C container
++
++- a += 2;
++- c += 2;
+++ a += 2;
+++ c += 2;
++ }
++
++- if((num_points % 2) != 0) {
++- *c = (*a) * scalar;
+++ if ((num_points % 2) != 0) {
+++ *c = (*a) * scalar;
++ }
++ }
++ #endif /* LV_HAVE_SSE */
++@@ -359,7 +389,11 @@ static inline void volk_32fc_s32fc_multiply_32fc_a_sse3(lv_32fc_t* cVector, cons
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_32fc_s32fc_multiply_32fc_neon(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t scalar, unsigned int num_points){
+++static inline void volk_32fc_s32fc_multiply_32fc_neon(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
++ lv_32fc_t* cPtr = cVector;
++ const lv_32fc_t* aPtr = aVector;
++ unsigned int number = num_points;
++@@ -370,7 +404,7 @@ static inline void volk_32fc_s32fc_multiply_32fc_neon(lv_32fc_t* cVector, const
++
++ scalar_val.val[0] = vld1q_dup_f32((const float*)&scalar);
++ scalar_val.val[1] = vld1q_dup_f32(((const float*)&scalar) + 1);
++- for(number = 0; number < quarter_points; ++number) {
+++ for (number = 0; number < quarter_points; ++number) {
++ a_val = vld2q_f32((float*)aPtr);
++ tmp_imag.val[1] = vmulq_f32(a_val.val[1], scalar_val.val[0]);
++ tmp_imag.val[0] = vmulq_f32(a_val.val[0], scalar_val.val[0]);
++@@ -383,35 +417,39 @@ static inline void volk_32fc_s32fc_multiply_32fc_neon(lv_32fc_t* cVector, const
++ cPtr += 4;
++ }
++
++- for(number = quarter_points*4; number < num_points; number++){
++- *cPtr++ = *aPtr++ * scalar;
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ *cPtr++ = *aPtr++ * scalar;
++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32fc_s32fc_multiply_32fc_a_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t scalar, unsigned int num_points){
+++static inline void volk_32fc_s32fc_multiply_32fc_a_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
++ lv_32fc_t* cPtr = cVector;
++ const lv_32fc_t* aPtr = aVector;
++ unsigned int number = num_points;
++
++ // unwrap loop
++- while (number >= 8){
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- *cPtr++ = (*aPtr++) * scalar;
++- number -= 8;
+++ while (number >= 8) {
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ *cPtr++ = (*aPtr++) * scalar;
+++ number -= 8;
++ }
++
++ // clean up any remaining
++ while (number-- > 0)
++- *cPtr++ = *aPtr++ * scalar;
+++ *cPtr++ = *aPtr++ * scalar;
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32fc_s32fc_rotatorpuppet_32fc.h b/kernels/volk/volk_32fc_s32fc_rotatorpuppet_32fc.h
++index 181abc5..eba98fe 100644
++--- a/kernels/volk/volk_32fc_s32fc_rotatorpuppet_32fc.h
+++++ b/kernels/volk/volk_32fc_s32fc_rotatorpuppet_32fc.h
++@@ -25,19 +25,24 @@
++ #define INCLUDED_volk_32fc_s32fc_rotatorpuppet_32fc_a_H
++
++
++-#include <volk/volk_complex.h>
++ #include <stdio.h>
++ #include <volk/volk_32fc_s32fc_x2_rotator_32fc.h>
+++#include <volk/volk_complex.h>
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32fc_s32fc_rotatorpuppet_32fc_generic(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, unsigned int num_points){
++- lv_32fc_t phase[1] = {lv_cmake(.3, 0.95393)};
+++static inline void volk_32fc_s32fc_rotatorpuppet_32fc_generic(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ unsigned int num_points)
+++{
+++ lv_32fc_t phase[1] = { lv_cmake(.3, 0.95393) };
++ (*phase) /= hypotf(lv_creal(*phase), lv_cimag(*phase));
++- const lv_32fc_t phase_inc_n = phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
++- volk_32fc_s32fc_x2_rotator_32fc_generic(outVector, inVector, phase_inc_n, phase, num_points);
++-
+++ const lv_32fc_t phase_inc_n =
+++ phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
+++ volk_32fc_s32fc_x2_rotator_32fc_generic(
+++ outVector, inVector, phase_inc_n, phase, num_points);
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -47,12 +52,17 @@ static inline void volk_32fc_s32fc_rotatorpuppet_32fc_generic(lv_32fc_t* outVect
++ #include <arm_neon.h>
++ #include <volk/volk_neon_intrinsics.h>
++
++-static inline void volk_32fc_s32fc_rotatorpuppet_32fc_neon(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, unsigned int num_points){
++- lv_32fc_t phase[1] = {lv_cmake(.3, 0.95393)};
+++static inline void volk_32fc_s32fc_rotatorpuppet_32fc_neon(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ unsigned int num_points)
+++{
+++ lv_32fc_t phase[1] = { lv_cmake(.3, 0.95393) };
++ (*phase) /= hypotf(lv_creal(*phase), lv_cimag(*phase));
++- const lv_32fc_t phase_inc_n = phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
++- volk_32fc_s32fc_x2_rotator_32fc_neon(outVector, inVector, phase_inc_n, phase, num_points);
++-
+++ const lv_32fc_t phase_inc_n =
+++ phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
+++ volk_32fc_s32fc_x2_rotator_32fc_neon(
+++ outVector, inVector, phase_inc_n, phase, num_points);
++ }
++
++ #endif /* LV_HAVE_NEON */
++@@ -61,12 +71,17 @@ static inline void volk_32fc_s32fc_rotatorpuppet_32fc_neon(lv_32fc_t* outVector,
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void volk_32fc_s32fc_rotatorpuppet_32fc_a_sse4_1(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, unsigned int num_points){
++- lv_32fc_t phase[1] = {lv_cmake(.3, .95393)};
+++static inline void volk_32fc_s32fc_rotatorpuppet_32fc_a_sse4_1(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ unsigned int num_points)
+++{
+++ lv_32fc_t phase[1] = { lv_cmake(.3, .95393) };
++ (*phase) /= hypotf(lv_creal(*phase), lv_cimag(*phase));
++- const lv_32fc_t phase_inc_n = phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
++- volk_32fc_s32fc_x2_rotator_32fc_a_sse4_1(outVector, inVector, phase_inc_n, phase, num_points);
++-
+++ const lv_32fc_t phase_inc_n =
+++ phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
+++ volk_32fc_s32fc_x2_rotator_32fc_a_sse4_1(
+++ outVector, inVector, phase_inc_n, phase, num_points);
++ }
++
++ #endif /* LV_HAVE_SSE4_1 */
++@@ -74,12 +89,17 @@ static inline void volk_32fc_s32fc_rotatorpuppet_32fc_a_sse4_1(lv_32fc_t* outVec
++
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++-static inline void volk_32fc_s32fc_rotatorpuppet_32fc_u_sse4_1(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, unsigned int num_points){
++- lv_32fc_t phase[1] = {lv_cmake(.3, .95393)};
+++static inline void volk_32fc_s32fc_rotatorpuppet_32fc_u_sse4_1(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ unsigned int num_points)
+++{
+++ lv_32fc_t phase[1] = { lv_cmake(.3, .95393) };
++ (*phase) /= hypotf(lv_creal(*phase), lv_cimag(*phase));
++- const lv_32fc_t phase_inc_n = phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
++- volk_32fc_s32fc_x2_rotator_32fc_u_sse4_1(outVector, inVector, phase_inc_n, phase, num_points);
++-
+++ const lv_32fc_t phase_inc_n =
+++ phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
+++ volk_32fc_s32fc_x2_rotator_32fc_u_sse4_1(
+++ outVector, inVector, phase_inc_n, phase, num_points);
++ }
++
++ #endif /* LV_HAVE_SSE4_1 */
++@@ -88,11 +108,17 @@ static inline void volk_32fc_s32fc_rotatorpuppet_32fc_u_sse4_1(lv_32fc_t* outVec
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32fc_s32fc_rotatorpuppet_32fc_a_avx(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, unsigned int num_points){
++- lv_32fc_t phase[1] = {lv_cmake(.3, .95393)};
+++static inline void volk_32fc_s32fc_rotatorpuppet_32fc_a_avx(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ unsigned int num_points)
+++{
+++ lv_32fc_t phase[1] = { lv_cmake(.3, .95393) };
++ (*phase) /= hypotf(lv_creal(*phase), lv_cimag(*phase));
++- const lv_32fc_t phase_inc_n = phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
++- volk_32fc_s32fc_x2_rotator_32fc_a_avx(outVector, inVector, phase_inc_n, phase, num_points);
+++ const lv_32fc_t phase_inc_n =
+++ phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
+++ volk_32fc_s32fc_x2_rotator_32fc_a_avx(
+++ outVector, inVector, phase_inc_n, phase, num_points);
++ }
++
++ #endif /* LV_HAVE_AVX */
++@@ -101,11 +127,17 @@ static inline void volk_32fc_s32fc_rotatorpuppet_32fc_a_avx(lv_32fc_t* outVector
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_32fc_s32fc_rotatorpuppet_32fc_u_avx(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, unsigned int num_points){
++- lv_32fc_t phase[1] = {lv_cmake(.3, .95393)};
+++static inline void volk_32fc_s32fc_rotatorpuppet_32fc_u_avx(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ unsigned int num_points)
+++{
+++ lv_32fc_t phase[1] = { lv_cmake(.3, .95393) };
++ (*phase) /= hypotf(lv_creal(*phase), lv_cimag(*phase));
++- const lv_32fc_t phase_inc_n = phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
++- volk_32fc_s32fc_x2_rotator_32fc_u_avx(outVector, inVector, phase_inc_n, phase, num_points);
+++ const lv_32fc_t phase_inc_n =
+++ phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
+++ volk_32fc_s32fc_x2_rotator_32fc_u_avx(
+++ outVector, inVector, phase_inc_n, phase, num_points);
++ }
++
++ #endif /* LV_HAVE_AVX */
++@@ -113,11 +145,17 @@ static inline void volk_32fc_s32fc_rotatorpuppet_32fc_u_avx(lv_32fc_t* outVector
++ #if LV_HAVE_AVX && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void volk_32fc_s32fc_rotatorpuppet_32fc_a_avx_fma(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, unsigned int num_points){
++- lv_32fc_t phase[1] = {lv_cmake(.3, .95393)};
+++static inline void volk_32fc_s32fc_rotatorpuppet_32fc_a_avx_fma(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ unsigned int num_points)
+++{
+++ lv_32fc_t phase[1] = { lv_cmake(.3, .95393) };
++ (*phase) /= hypotf(lv_creal(*phase), lv_cimag(*phase));
++- const lv_32fc_t phase_inc_n = phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
++- volk_32fc_s32fc_x2_rotator_32fc_a_avx_fma(outVector, inVector, phase_inc_n, phase, num_points);
+++ const lv_32fc_t phase_inc_n =
+++ phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
+++ volk_32fc_s32fc_x2_rotator_32fc_a_avx_fma(
+++ outVector, inVector, phase_inc_n, phase, num_points);
++ }
++
++ #endif /* LV_HAVE_AVX && LV_HAVE_FMA*/
++@@ -126,11 +164,17 @@ static inline void volk_32fc_s32fc_rotatorpuppet_32fc_a_avx_fma(lv_32fc_t* outVe
++ #if LV_HAVE_AVX && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void volk_32fc_s32fc_rotatorpuppet_32fc_u_avx_fma(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, unsigned int num_points){
++- lv_32fc_t phase[1] = {lv_cmake(.3, .95393)};
+++static inline void volk_32fc_s32fc_rotatorpuppet_32fc_u_avx_fma(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ unsigned int num_points)
+++{
+++ lv_32fc_t phase[1] = { lv_cmake(.3, .95393) };
++ (*phase) /= hypotf(lv_creal(*phase), lv_cimag(*phase));
++- const lv_32fc_t phase_inc_n = phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
++- volk_32fc_s32fc_x2_rotator_32fc_u_avx_fma(outVector, inVector, phase_inc_n, phase, num_points);
+++ const lv_32fc_t phase_inc_n =
+++ phase_inc / hypotf(lv_creal(phase_inc), lv_cimag(phase_inc));
+++ volk_32fc_s32fc_x2_rotator_32fc_u_avx_fma(
+++ outVector, inVector, phase_inc_n, phase, num_points);
++ }
++
++ #endif /* LV_HAVE_AVX && LV_HAVE_FMA*/
++diff --git a/kernels/volk/volk_32fc_s32fc_x2_rotator_32fc.h b/kernels/volk/volk_32fc_s32fc_x2_rotator_32fc.h
++index a886458..c97b8cb 100644
++--- a/kernels/volk/volk_32fc_s32fc_x2_rotator_32fc.h
+++++ b/kernels/volk/volk_32fc_s32fc_x2_rotator_32fc.h
++@@ -30,14 +30,15 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_s32fc_x2_rotator_32fc(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_s32fc_x2_rotator_32fc(lv_32fc_t* outVector, const lv_32fc_t* inVector,
+++ * const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li inVector: Vector to be rotated.
++ * \li phase_inc: rotational velocity.
++ * \li phase: initial phase offset.
++- * \li num_points: The number of values in inVector to be rotated and stored into outVector.
+++ * \li num_points: The number of values in inVector to be rotated and stored into
+++ * outVector.
++ *
++ * \b Outputs
++ * \li outVector: The vector where the results will be stored.
++@@ -81,31 +82,36 @@
++ #define INCLUDED_volk_32fc_s32fc_rotator_32fc_a_H
++
++
++-#include <volk/volk_complex.h>
+++#include <math.h>
++ #include <stdio.h>
++ #include <stdlib.h>
++-#include <math.h>
+++#include <volk/volk_complex.h>
++ #define ROTATOR_RELOAD 512
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32fc_s32fc_x2_rotator_32fc_generic(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points){
+++static inline void volk_32fc_s32fc_x2_rotator_32fc_generic(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ lv_32fc_t* phase,
+++ unsigned int num_points)
+++{
++ unsigned int i = 0;
++ int j = 0;
++- for(i = 0; i < (unsigned int)(num_points/ROTATOR_RELOAD); ++i) {
++- for(j = 0; j < ROTATOR_RELOAD; ++j) {
+++ for (i = 0; i < (unsigned int)(num_points / ROTATOR_RELOAD); ++i) {
+++ for (j = 0; j < ROTATOR_RELOAD; ++j) {
++ *outVector++ = *inVector++ * (*phase);
++ (*phase) *= phase_inc;
++ }
++
++ (*phase) /= hypotf(lv_creal(*phase), lv_cimag(*phase));
++ }
++- for(i = 0; i < num_points%ROTATOR_RELOAD; ++i) {
+++ for (i = 0; i < num_points % ROTATOR_RELOAD; ++i) {
++ *outVector++ = *inVector++ * (*phase);
++ (*phase) *= phase_inc;
++ }
++- if(i){
+++ if (i) {
++ // Make sure, we normalize phase on every call!
++ (*phase) /= hypotf(lv_creal(*phase), lv_cimag(*phase));
++ }
++@@ -118,43 +124,47 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_generic(lv_32fc_t* outVector,
++ #include <arm_neon.h>
++ #include <volk/volk_neon_intrinsics.h>
++
++-static inline void volk_32fc_s32fc_x2_rotator_32fc_neon(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points)
+++static inline void volk_32fc_s32fc_x2_rotator_32fc_neon(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ lv_32fc_t* phase,
+++ unsigned int num_points)
++
++ {
++ lv_32fc_t* outputVectorPtr = outVector;
++ const lv_32fc_t* inputVectorPtr = inVector;
++ lv_32fc_t incr = 1;
++- lv_32fc_t phasePtr[4] = {(*phase), (*phase), (*phase), (*phase)};
+++ lv_32fc_t phasePtr[4] = { (*phase), (*phase), (*phase), (*phase) };
++ float32x4x2_t input_vec;
++ float32x4x2_t output_vec;
++-
+++
++ unsigned int i = 0, j = 0;
++ const unsigned int quarter_points = num_points / 4;
++-
++- for(i = 0; i < 4; ++i) {
+++
+++ for (i = 0; i < 4; ++i) {
++ phasePtr[i] *= incr;
++ incr *= (phase_inc);
++ }
++-
+++
++ // Notice that incr has be incremented in the previous loop
++- const lv_32fc_t incrPtr[4] = {incr, incr, incr, incr};
++- const float32x4x2_t incr_vec = vld2q_f32((float*) incrPtr);
++- float32x4x2_t phase_vec = vld2q_f32((float*) phasePtr);
++-
++- for(i = 0; i < (unsigned int)(quarter_points/ROTATOR_RELOAD); i++) {
++- for(j = 0; j < ROTATOR_RELOAD; j++) {
++- input_vec = vld2q_f32((float*) inputVectorPtr);
+++ const lv_32fc_t incrPtr[4] = { incr, incr, incr, incr };
+++ const float32x4x2_t incr_vec = vld2q_f32((float*)incrPtr);
+++ float32x4x2_t phase_vec = vld2q_f32((float*)phasePtr);
+++
+++ for (i = 0; i < (unsigned int)(quarter_points / ROTATOR_RELOAD); i++) {
+++ for (j = 0; j < ROTATOR_RELOAD; j++) {
+++ input_vec = vld2q_f32((float*)inputVectorPtr);
++ // Prefetch next one, speeds things up
++- __VOLK_PREFETCH(inputVectorPtr+4);
+++ __VOLK_PREFETCH(inputVectorPtr + 4);
++ // Rotate
++ output_vec = _vmultiply_complexq_f32(input_vec, phase_vec);
++ // Increase phase
++ phase_vec = _vmultiply_complexq_f32(phase_vec, incr_vec);
++ // Store output
++ vst2q_f32((float*)outputVectorPtr, output_vec);
++-
++- outputVectorPtr+=4;
++- inputVectorPtr+=4;
+++
+++ outputVectorPtr += 4;
+++ inputVectorPtr += 4;
++ }
++ // normalize phase so magnitude doesn't grow because of
++ // floating point rounding error
++@@ -164,20 +174,20 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_neon(lv_32fc_t* outVector, co
++ phase_vec.val[0] = vmulq_f32(phase_vec.val[0], inv_mag);
++ phase_vec.val[1] = vmulq_f32(phase_vec.val[1], inv_mag);
++ }
++-
++- for(i = 0; i < quarter_points % ROTATOR_RELOAD; i++) {
++- input_vec = vld2q_f32((float*) inputVectorPtr);
+++
+++ for (i = 0; i < quarter_points % ROTATOR_RELOAD; i++) {
+++ input_vec = vld2q_f32((float*)inputVectorPtr);
++ // Prefetch next one, speeds things up
++- __VOLK_PREFETCH(inputVectorPtr+4);
+++ __VOLK_PREFETCH(inputVectorPtr + 4);
++ // Rotate
++ output_vec = _vmultiply_complexq_f32(input_vec, phase_vec);
++ // Increase phase
++ phase_vec = _vmultiply_complexq_f32(phase_vec, incr_vec);
++ // Store output
++ vst2q_f32((float*)outputVectorPtr, output_vec);
++-
++- outputVectorPtr+=4;
++- inputVectorPtr+=4;
+++
+++ outputVectorPtr += 4;
+++ inputVectorPtr += 4;
++ }
++ // if(i) == true means we looped above
++ if (i) {
++@@ -191,13 +201,13 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_neon(lv_32fc_t* outVector, co
++ }
++ // Store current phase
++ vst2q_f32((float*)phasePtr, phase_vec);
++-
+++
++ // Deal with the rest
++- for(i = 0; i < num_points % 4; i++) {
+++ for (i = 0; i < num_points % 4; i++) {
++ *outputVectorPtr++ = *inputVectorPtr++ * phasePtr[0];
++ phasePtr[0] *= (phase_inc);
++ }
++-
+++
++ // For continious phase next time we need to call this function
++ (*phase) = phasePtr[0];
++ }
++@@ -208,15 +218,20 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_neon(lv_32fc_t* outVector, co
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void volk_32fc_s32fc_x2_rotator_32fc_a_sse4_1(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points){
+++static inline void volk_32fc_s32fc_x2_rotator_32fc_a_sse4_1(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ lv_32fc_t* phase,
+++ unsigned int num_points)
+++{
++ lv_32fc_t* cPtr = outVector;
++ const lv_32fc_t* aPtr = inVector;
++ lv_32fc_t incr = 1;
++- lv_32fc_t phase_Ptr[2] = {(*phase), (*phase)};
+++ lv_32fc_t phase_Ptr[2] = { (*phase), (*phase) };
++
++ unsigned int i, j = 0;
++
++- for(i = 0; i < 2; ++i) {
+++ for (i = 0; i < 2; ++i) {
++ phase_Ptr[i] *= incr;
++ incr *= (phase_inc);
++ }
++@@ -227,13 +242,13 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_a_sse4_1(lv_32fc_t* outVector
++ __m128 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
++
++ phase_Val = _mm_loadu_ps((float*)phase_Ptr);
++- inc_Val = _mm_set_ps(lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr));
+++ inc_Val = _mm_set_ps(lv_cimag(incr), lv_creal(incr), lv_cimag(incr), lv_creal(incr));
++
++ const unsigned int halfPoints = num_points / 2;
++
++
++- for(i = 0; i < (unsigned int)(halfPoints/ROTATOR_RELOAD); i++) {
++- for(j = 0; j < ROTATOR_RELOAD; ++j) {
+++ for (i = 0; i < (unsigned int)(halfPoints / ROTATOR_RELOAD); i++) {
+++ for (j = 0; j < ROTATOR_RELOAD; ++j) {
++
++ aVal = _mm_load_ps((float*)aPtr);
++
++@@ -264,7 +279,7 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_a_sse4_1(lv_32fc_t* outVector
++ tmp2 = _mm_sqrt_ps(tmp1);
++ phase_Val = _mm_div_ps(phase_Val, tmp2);
++ }
++- for(i = 0; i < halfPoints%ROTATOR_RELOAD; ++i) {
+++ for (i = 0; i < halfPoints % ROTATOR_RELOAD; ++i) {
++ aVal = _mm_load_ps((float*)aPtr);
++
++ yl = _mm_moveldup_ps(phase_Val);
++@@ -304,7 +319,6 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_a_sse4_1(lv_32fc_t* outVector
++ }
++
++ (*phase) = phase_Ptr[0];
++-
++ }
++
++ #endif /* LV_HAVE_SSE4_1 for aligned */
++@@ -313,15 +327,20 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_a_sse4_1(lv_32fc_t* outVector
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void volk_32fc_s32fc_x2_rotator_32fc_u_sse4_1(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points){
+++static inline void volk_32fc_s32fc_x2_rotator_32fc_u_sse4_1(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ lv_32fc_t* phase,
+++ unsigned int num_points)
+++{
++ lv_32fc_t* cPtr = outVector;
++ const lv_32fc_t* aPtr = inVector;
++ lv_32fc_t incr = 1;
++- lv_32fc_t phase_Ptr[2] = {(*phase), (*phase)};
+++ lv_32fc_t phase_Ptr[2] = { (*phase), (*phase) };
++
++ unsigned int i, j = 0;
++
++- for(i = 0; i < 2; ++i) {
+++ for (i = 0; i < 2; ++i) {
++ phase_Ptr[i] *= incr;
++ incr *= (phase_inc);
++ }
++@@ -332,13 +351,13 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_u_sse4_1(lv_32fc_t* outVector
++ __m128 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
++
++ phase_Val = _mm_loadu_ps((float*)phase_Ptr);
++- inc_Val = _mm_set_ps(lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr));
+++ inc_Val = _mm_set_ps(lv_cimag(incr), lv_creal(incr), lv_cimag(incr), lv_creal(incr));
++
++ const unsigned int halfPoints = num_points / 2;
++
++
++- for(i = 0; i < (unsigned int)(halfPoints/ROTATOR_RELOAD); i++) {
++- for(j = 0; j < ROTATOR_RELOAD; ++j) {
+++ for (i = 0; i < (unsigned int)(halfPoints / ROTATOR_RELOAD); i++) {
+++ for (j = 0; j < ROTATOR_RELOAD; ++j) {
++
++ aVal = _mm_loadu_ps((float*)aPtr);
++
++@@ -369,7 +388,7 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_u_sse4_1(lv_32fc_t* outVector
++ tmp2 = _mm_sqrt_ps(tmp1);
++ phase_Val = _mm_div_ps(phase_Val, tmp2);
++ }
++- for(i = 0; i < halfPoints%ROTATOR_RELOAD; ++i) {
+++ for (i = 0; i < halfPoints % ROTATOR_RELOAD; ++i) {
++ aVal = _mm_loadu_ps((float*)aPtr);
++
++ yl = _mm_moveldup_ps(phase_Val);
++@@ -409,7 +428,6 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_u_sse4_1(lv_32fc_t* outVector
++ }
++
++ (*phase) = phase_Ptr[0];
++-
++ }
++
++ #endif /* LV_HAVE_SSE4_1 */
++@@ -419,15 +437,20 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_u_sse4_1(lv_32fc_t* outVector
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points){
+++static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ lv_32fc_t* phase,
+++ unsigned int num_points)
+++{
++ lv_32fc_t* cPtr = outVector;
++ const lv_32fc_t* aPtr = inVector;
++ lv_32fc_t incr = lv_cmake(1.0, 0.0);
++- lv_32fc_t phase_Ptr[4] = {(*phase), (*phase), (*phase), (*phase)};
+++ lv_32fc_t phase_Ptr[4] = { (*phase), (*phase), (*phase), (*phase) };
++
++ unsigned int i, j = 0;
++
++- for(i = 0; i < 4; ++i) {
+++ for (i = 0; i < 4; ++i) {
++ phase_Ptr[i] *= incr;
++ incr *= (phase_inc);
++ }
++@@ -435,16 +458,20 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx(lv_32fc_t* outVector, c
++ __m256 aVal, phase_Val, z;
++
++ phase_Val = _mm256_loadu_ps((float*)phase_Ptr);
++-
++- const __m256 inc_Val = _mm256_set_ps(lv_cimag(incr), lv_creal(incr),
++- lv_cimag(incr), lv_creal(incr),
++- lv_cimag(incr), lv_creal(incr),
++- lv_cimag(incr), lv_creal(incr));
+++
+++ const __m256 inc_Val = _mm256_set_ps(lv_cimag(incr),
+++ lv_creal(incr),
+++ lv_cimag(incr),
+++ lv_creal(incr),
+++ lv_cimag(incr),
+++ lv_creal(incr),
+++ lv_cimag(incr),
+++ lv_creal(incr));
++
++ const unsigned int fourthPoints = num_points / 4;
++
++- for(i = 0; i < (unsigned int)(fourthPoints/ROTATOR_RELOAD); i++) {
++- for(j = 0; j < ROTATOR_RELOAD; ++j) {
+++ for (i = 0; i < (unsigned int)(fourthPoints / ROTATOR_RELOAD); i++) {
+++ for (j = 0; j < ROTATOR_RELOAD; ++j) {
++
++ aVal = _mm256_load_ps((float*)aPtr);
++
++@@ -458,8 +485,8 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx(lv_32fc_t* outVector, c
++ }
++ phase_Val = _mm256_normalize_ps(phase_Val);
++ }
++-
++- for(i = 0; i < fourthPoints%ROTATOR_RELOAD; ++i) {
+++
+++ for (i = 0; i < fourthPoints % ROTATOR_RELOAD; ++i) {
++ aVal = _mm256_load_ps((float*)aPtr);
++
++ z = _mm256_complexmul_ps(aVal, phase_Val);
++@@ -473,10 +500,10 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx(lv_32fc_t* outVector, c
++ if (i) {
++ phase_Val = _mm256_normalize_ps(phase_Val);
++ }
++-
+++
++ _mm256_storeu_ps((float*)phase_Ptr, phase_Val);
++ (*phase) = phase_Ptr[0];
++- volk_32fc_s32fc_x2_rotator_32fc_generic(cPtr, aPtr, phase_inc, phase, num_points%4);
+++ volk_32fc_s32fc_x2_rotator_32fc_generic(cPtr, aPtr, phase_inc, phase, num_points % 4);
++ }
++
++ #endif /* LV_HAVE_AVX for aligned */
++@@ -486,15 +513,20 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx(lv_32fc_t* outVector, c
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void volk_32fc_s32fc_x2_rotator_32fc_u_avx(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points){
+++static inline void volk_32fc_s32fc_x2_rotator_32fc_u_avx(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ lv_32fc_t* phase,
+++ unsigned int num_points)
+++{
++ lv_32fc_t* cPtr = outVector;
++ const lv_32fc_t* aPtr = inVector;
++ lv_32fc_t incr = lv_cmake(1.0, 0.0);
++- lv_32fc_t phase_Ptr[4] = {(*phase), (*phase), (*phase), (*phase)};
+++ lv_32fc_t phase_Ptr[4] = { (*phase), (*phase), (*phase), (*phase) };
++
++ unsigned int i, j = 0;
++
++- for(i = 0; i < 4; ++i) {
+++ for (i = 0; i < 4; ++i) {
++ phase_Ptr[i] *= incr;
++ incr *= (phase_inc);
++ }
++@@ -502,19 +534,23 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_u_avx(lv_32fc_t* outVector, c
++ __m256 aVal, phase_Val, z;
++
++ phase_Val = _mm256_loadu_ps((float*)phase_Ptr);
++-
++- const __m256 inc_Val = _mm256_set_ps(lv_cimag(incr), lv_creal(incr),
++- lv_cimag(incr), lv_creal(incr),
++- lv_cimag(incr), lv_creal(incr),
++- lv_cimag(incr), lv_creal(incr));
++-
+++
+++ const __m256 inc_Val = _mm256_set_ps(lv_cimag(incr),
+++ lv_creal(incr),
+++ lv_cimag(incr),
+++ lv_creal(incr),
+++ lv_cimag(incr),
+++ lv_creal(incr),
+++ lv_cimag(incr),
+++ lv_creal(incr));
+++
++ const unsigned int fourthPoints = num_points / 4;
++
++- for(i = 0; i < (unsigned int)(fourthPoints/ROTATOR_RELOAD); ++i) {
++- for(j = 0; j < ROTATOR_RELOAD; ++j) {
+++ for (i = 0; i < (unsigned int)(fourthPoints / ROTATOR_RELOAD); ++i) {
+++ for (j = 0; j < ROTATOR_RELOAD; ++j) {
++
++ aVal = _mm256_loadu_ps((float*)aPtr);
++-
+++
++ z = _mm256_complexmul_ps(aVal, phase_Val);
++ phase_Val = _mm256_complexmul_ps(phase_Val, inc_Val);
++
++@@ -524,10 +560,9 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_u_avx(lv_32fc_t* outVector, c
++ cPtr += 4;
++ }
++ phase_Val = _mm256_normalize_ps(phase_Val);
++-
++ }
++-
++- for(i = 0; i < fourthPoints%ROTATOR_RELOAD; ++i) {
+++
+++ for (i = 0; i < num_points % ROTATOR_RELOAD; ++i) {
++ aVal = _mm256_loadu_ps((float*)aPtr);
++
++ z = _mm256_complexmul_ps(aVal, phase_Val);
++@@ -544,7 +579,7 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_u_avx(lv_32fc_t* outVector, c
++
++ _mm256_storeu_ps((float*)phase_Ptr, phase_Val);
++ (*phase) = phase_Ptr[0];
++- volk_32fc_s32fc_x2_rotator_32fc_generic(cPtr, aPtr, phase_inc, phase, num_points%4);
+++ volk_32fc_s32fc_x2_rotator_32fc_generic(cPtr, aPtr, phase_inc, phase, num_points % 4);
++ }
++
++ #endif /* LV_HAVE_AVX */
++@@ -552,15 +587,21 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_u_avx(lv_32fc_t* outVector, c
++ #if LV_HAVE_AVX && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx_fma(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points){
+++static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx_fma(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ lv_32fc_t* phase,
+++ unsigned int num_points)
+++{
++ lv_32fc_t* cPtr = outVector;
++ const lv_32fc_t* aPtr = inVector;
++ lv_32fc_t incr = 1;
++- __VOLK_ATTR_ALIGNED(32) lv_32fc_t phase_Ptr[4] = {(*phase), (*phase), (*phase), (*phase)};
+++ __VOLK_ATTR_ALIGNED(32)
+++ lv_32fc_t phase_Ptr[4] = { (*phase), (*phase), (*phase), (*phase) };
++
++ unsigned int i, j = 0;
++
++- for(i = 0; i < 4; ++i) {
+++ for (i = 0; i < 4; ++i) {
++ phase_Ptr[i] *= incr;
++ incr *= (phase_inc);
++ }
++@@ -568,11 +609,18 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx_fma(lv_32fc_t* outVecto
++ __m256 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
++
++ phase_Val = _mm256_load_ps((float*)phase_Ptr);
++- inc_Val = _mm256_set_ps(lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr));
+++ inc_Val = _mm256_set_ps(lv_cimag(incr),
+++ lv_creal(incr),
+++ lv_cimag(incr),
+++ lv_creal(incr),
+++ lv_cimag(incr),
+++ lv_creal(incr),
+++ lv_cimag(incr),
+++ lv_creal(incr));
++ const unsigned int fourthPoints = num_points / 4;
++
++- for(i = 0; i < (unsigned int)(fourthPoints/ROTATOR_RELOAD); i++) {
++- for(j = 0; j < ROTATOR_RELOAD; ++j) {
+++ for (i = 0; i < (unsigned int)(fourthPoints / ROTATOR_RELOAD); i++) {
+++ for (j = 0; j < ROTATOR_RELOAD; ++j) {
++
++ aVal = _mm256_load_ps((float*)aPtr);
++
++@@ -603,7 +651,7 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx_fma(lv_32fc_t* outVecto
++ tmp2 = _mm256_sqrt_ps(tmp1);
++ phase_Val = _mm256_div_ps(phase_Val, tmp2);
++ }
++- for(i = 0; i < fourthPoints%ROTATOR_RELOAD; ++i) {
+++ for (i = 0; i < fourthPoints % ROTATOR_RELOAD; ++i) {
++ aVal = _mm256_load_ps((float*)aPtr);
++
++ yl = _mm256_moveldup_ps(phase_Val);
++@@ -636,13 +684,12 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx_fma(lv_32fc_t* outVecto
++ }
++
++ _mm256_store_ps((float*)phase_Ptr, phase_Val);
++- for(i = 0; i < num_points%4; ++i) {
+++ for (i = 0; i < num_points % 4; ++i) {
++ *cPtr++ = *aPtr++ * phase_Ptr[0];
++ phase_Ptr[0] *= (phase_inc);
++ }
++
++ (*phase) = phase_Ptr[0];
++-
++ }
++
++ #endif /* LV_HAVE_AVX && LV_HAVE_FMA for aligned*/
++@@ -650,15 +697,20 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_a_avx_fma(lv_32fc_t* outVecto
++ #if LV_HAVE_AVX && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void volk_32fc_s32fc_x2_rotator_32fc_u_avx_fma(lv_32fc_t* outVector, const lv_32fc_t* inVector, const lv_32fc_t phase_inc, lv_32fc_t* phase, unsigned int num_points){
+++static inline void volk_32fc_s32fc_x2_rotator_32fc_u_avx_fma(lv_32fc_t* outVector,
+++ const lv_32fc_t* inVector,
+++ const lv_32fc_t phase_inc,
+++ lv_32fc_t* phase,
+++ unsigned int num_points)
+++{
++ lv_32fc_t* cPtr = outVector;
++ const lv_32fc_t* aPtr = inVector;
++ lv_32fc_t incr = 1;
++- lv_32fc_t phase_Ptr[4] = {(*phase), (*phase), (*phase), (*phase)};
+++ lv_32fc_t phase_Ptr[4] = { (*phase), (*phase), (*phase), (*phase) };
++
++ unsigned int i, j = 0;
++
++- for(i = 0; i < 4; ++i) {
+++ for (i = 0; i < 4; ++i) {
++ phase_Ptr[i] *= incr;
++ incr *= (phase_inc);
++ }
++@@ -666,11 +718,18 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_u_avx_fma(lv_32fc_t* outVecto
++ __m256 aVal, phase_Val, inc_Val, yl, yh, tmp1, tmp2, z, ylp, yhp, tmp1p, tmp2p;
++
++ phase_Val = _mm256_loadu_ps((float*)phase_Ptr);
++- inc_Val = _mm256_set_ps(lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr),lv_cimag(incr), lv_creal(incr));
+++ inc_Val = _mm256_set_ps(lv_cimag(incr),
+++ lv_creal(incr),
+++ lv_cimag(incr),
+++ lv_creal(incr),
+++ lv_cimag(incr),
+++ lv_creal(incr),
+++ lv_cimag(incr),
+++ lv_creal(incr));
++ const unsigned int fourthPoints = num_points / 4;
++
++- for(i = 0; i < (unsigned int)(fourthPoints/ROTATOR_RELOAD); i++) {
++- for(j = 0; j < ROTATOR_RELOAD; ++j) {
+++ for (i = 0; i < (unsigned int)(fourthPoints / ROTATOR_RELOAD); i++) {
+++ for (j = 0; j < ROTATOR_RELOAD; ++j) {
++
++ aVal = _mm256_loadu_ps((float*)aPtr);
++
++@@ -701,7 +760,7 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_u_avx_fma(lv_32fc_t* outVecto
++ tmp2 = _mm256_sqrt_ps(tmp1);
++ phase_Val = _mm256_div_ps(phase_Val, tmp2);
++ }
++- for(i = 0; i < fourthPoints%ROTATOR_RELOAD; ++i) {
+++ for (i = 0; i < fourthPoints % ROTATOR_RELOAD; ++i) {
++ aVal = _mm256_loadu_ps((float*)aPtr);
++
++ yl = _mm256_moveldup_ps(phase_Val);
++@@ -734,13 +793,12 @@ static inline void volk_32fc_s32fc_x2_rotator_32fc_u_avx_fma(lv_32fc_t* outVecto
++ }
++
++ _mm256_storeu_ps((float*)phase_Ptr, phase_Val);
++- for(i = 0; i < num_points%4; ++i) {
+++ for (i = 0; i < num_points % 4; ++i) {
++ *cPtr++ = *aPtr++ * phase_Ptr[0];
++ phase_Ptr[0] *= (phase_inc);
++ }
++
++ (*phase) = phase_Ptr[0];
++-
++ }
++
++ #endif /* LV_HAVE_AVX && LV_HAVE_FMA*/
++diff --git a/kernels/volk/volk_32fc_x2_add_32fc.h b/kernels/volk/volk_32fc_x2_add_32fc.h
++index 90ff787..e7356c3 100644
++--- a/kernels/volk/volk_32fc_x2_add_32fc.h
+++++ b/kernels/volk/volk_32fc_x2_add_32fc.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_x2_add_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_x2_add_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const
+++ * lv_32fc_t* bVector, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: First vector of input points.
++@@ -44,7 +44,8 @@
++ *
++ * \b Example
++ *
++- * The follow example adds the increasing and decreasing vectors such that the result of every summation pair is 10
+++ * The follow example adds the increasing and decreasing vectors such that the result of
+++ * every summation pair is 10
++ *
++ * \code
++ * int N = 10;
++@@ -76,36 +77,38 @@
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_x2_add_32fc_u_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_add_32fc_u_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const lv_32fc_t* bPtr= bVector;
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const lv_32fc_t* bPtr = bVector;
++
++- __m256 aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
+++ __m256 aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm256_loadu_ps((float *) aPtr);
++- bVal = _mm256_loadu_ps((float *) bPtr);
+++ aVal = _mm256_loadu_ps((float*)aPtr);
+++ bVal = _mm256_loadu_ps((float*)bPtr);
++
++- cVal = _mm256_add_ps(aVal, bVal);
+++ cVal = _mm256_add_ps(aVal, bVal);
++
++- _mm256_storeu_ps((float *) cPtr,cVal); // Store the results back into the C container
+++ _mm256_storeu_ps((float*)cPtr,
+++ cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -113,36 +116,38 @@ volk_32fc_x2_add_32fc_u_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_32fc_x2_add_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_add_32fc_a_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const lv_32fc_t* bPtr= bVector;
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const lv_32fc_t* bPtr = bVector;
++
++- __m256 aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
+++ __m256 aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm256_load_ps((float*) aPtr);
++- bVal = _mm256_load_ps((float*) bPtr);
+++ aVal = _mm256_load_ps((float*)aPtr);
+++ bVal = _mm256_load_ps((float*)bPtr);
++
++- cVal = _mm256_add_ps(aVal, bVal);
+++ cVal = _mm256_add_ps(aVal, bVal);
++
++- _mm256_store_ps((float*) cPtr,cVal); // Store the results back into the C container
+++ _mm256_store_ps((float*)cPtr,
+++ cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -150,54 +155,56 @@ volk_32fc_x2_add_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32fc_x2_add_32fc_u_sse(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_add_32fc_u_sse(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int halfPoints = num_points / 2;
+++ unsigned int number = 0;
+++ const unsigned int halfPoints = num_points / 2;
++
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const lv_32fc_t* bPtr= bVector;
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const lv_32fc_t* bPtr = bVector;
++
++- __m128 aVal, bVal, cVal;
++- for(;number < halfPoints; number++){
+++ __m128 aVal, bVal, cVal;
+++ for (; number < halfPoints; number++) {
++
++- aVal = _mm_loadu_ps((float *) aPtr);
++- bVal = _mm_loadu_ps((float *) bPtr);
+++ aVal = _mm_loadu_ps((float*)aPtr);
+++ bVal = _mm_loadu_ps((float*)bPtr);
++
++- cVal = _mm_add_ps(aVal, bVal);
+++ cVal = _mm_add_ps(aVal, bVal);
++
++- _mm_storeu_ps((float*) cPtr, cVal); // Store the results back into the C container
+++ _mm_storeu_ps((float*)cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 2;
++- bPtr += 2;
++- cPtr += 2;
++- }
+++ aPtr += 2;
+++ bPtr += 2;
+++ cPtr += 2;
+++ }
++
++- number = halfPoints * 2;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ number = halfPoints * 2;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_x2_add_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_add_32fc_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const lv_32fc_t* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const lv_32fc_t* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -205,34 +212,36 @@ volk_32fc_x2_add_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32fc_x2_add_32fc_a_sse(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_add_32fc_a_sse(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int halfPoints = num_points / 2;
+++ unsigned int number = 0;
+++ const unsigned int halfPoints = num_points / 2;
++
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const lv_32fc_t* bPtr= bVector;
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const lv_32fc_t* bPtr = bVector;
++
++- __m128 aVal, bVal, cVal;
++- for(;number < halfPoints; number++){
++- aVal = _mm_load_ps((float *) aPtr);
++- bVal = _mm_load_ps((float *) bPtr);
+++ __m128 aVal, bVal, cVal;
+++ for (; number < halfPoints; number++) {
+++ aVal = _mm_load_ps((float*)aPtr);
+++ bVal = _mm_load_ps((float*)bPtr);
++
++- cVal = _mm_add_ps(aVal, bVal);
+++ cVal = _mm_add_ps(aVal, bVal);
++
++- _mm_store_ps((float *) cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps((float*)cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 2;
++- bPtr += 2;
++- cPtr += 2;
++- }
+++ aPtr += 2;
+++ bPtr += 2;
+++ cPtr += 2;
+++ }
++
++- number = halfPoints * 2;
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ number = halfPoints * 2;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -240,38 +249,39 @@ volk_32fc_x2_add_32fc_a_sse(lv_32fc_t* cVector, const lv_32fc_t* aVector, const
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32fc_x2_add_32fc_u_neon(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_add_32fc_u_neon(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int halfPoints = num_points / 2;
++-
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const lv_32fc_t* bPtr= bVector;
++- float32x4_t aVal, bVal, cVal;
++- for(number=0; number < halfPoints; number++){
++- // Load in to NEON registers
++- aVal = vld1q_f32((const float32_t*)(aPtr));
++- bVal = vld1q_f32((const float32_t*)(bPtr));
++- __VOLK_PREFETCH(aPtr+2);
++- __VOLK_PREFETCH(bPtr+2);
++-
++- // vector add
++- cVal = vaddq_f32(aVal, bVal);
++- // Store the results back into the C container
++- vst1q_f32((float*)(cPtr),cVal);
++-
++- aPtr += 2; // q uses quadwords, 4 lv_32fc_ts per vadd
++- bPtr += 2;
++- cPtr += 2;
++- }
++-
++- number = halfPoints * 2; // should be = num_points
++- for(;number < num_points; number++){
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ unsigned int number = 0;
+++ const unsigned int halfPoints = num_points / 2;
+++
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const lv_32fc_t* bPtr = bVector;
+++ float32x4_t aVal, bVal, cVal;
+++ for (number = 0; number < halfPoints; number++) {
+++ // Load in to NEON registers
+++ aVal = vld1q_f32((const float32_t*)(aPtr));
+++ bVal = vld1q_f32((const float32_t*)(bPtr));
+++ __VOLK_PREFETCH(aPtr + 2);
+++ __VOLK_PREFETCH(bPtr + 2);
+++
+++ // vector add
+++ cVal = vaddq_f32(aVal, bVal);
+++ // Store the results back into the C container
+++ vst1q_f32((float*)(cPtr), cVal);
+++
+++ aPtr += 2; // q uses quadwords, 4 lv_32fc_ts per vadd
+++ bPtr += 2;
+++ cPtr += 2;
+++ }
+++
+++ number = halfPoints * 2; // should be = num_points
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_NEON */
++diff --git a/kernels/volk/volk_32fc_x2_conjugate_dot_prod_32fc.h b/kernels/volk/volk_32fc_x2_conjugate_dot_prod_32fc.h
++index 77432ec..0f69499 100644
++--- a/kernels/volk/volk_32fc_x2_conjugate_dot_prod_32fc.h
+++++ b/kernels/volk/volk_32fc_x2_conjugate_dot_prod_32fc.h
++@@ -34,8 +34,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_x2_conjugate_dot_prod_32fc(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_x2_conjugate_dot_prod_32fc(lv_32fc_t* result, const lv_32fc_t* input,
+++ * const lv_32fc_t* taps, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li input: vector of complex floats.
++@@ -60,40 +60,44 @@
++ #define INCLUDED_volk_32fc_x2_conjugate_dot_prod_32fc_u_H
++
++
++-#include<volk/volk_complex.h>
+++#include <volk/volk_complex.h>
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32fc_x2_conjugate_dot_prod_32fc_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_conjugate_dot_prod_32fc_generic(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- const unsigned int num_bytes = num_points*8;
+++ const unsigned int num_bytes = num_points * 8;
++
++- float * res = (float*) result;
++- float * in = (float*) input;
++- float * tp = (float*) taps;
++- unsigned int n_2_ccomplex_blocks = num_bytes >> 4;
+++ float* res = (float*)result;
+++ float* in = (float*)input;
+++ float* tp = (float*)taps;
+++ unsigned int n_2_ccomplex_blocks = num_bytes >> 4;
++
++- float sum0[2] = {0,0};
++- float sum1[2] = {0,0};
++- unsigned int i = 0;
+++ float sum0[2] = { 0, 0 };
+++ float sum1[2] = { 0, 0 };
+++ unsigned int i = 0;
++
++- for(i = 0; i < n_2_ccomplex_blocks; ++i) {
++- sum0[0] += in[0] * tp[0] + in[1] * tp[1];
++- sum0[1] += (-in[0] * tp[1]) + in[1] * tp[0];
++- sum1[0] += in[2] * tp[2] + in[3] * tp[3];
++- sum1[1] += (-in[2] * tp[3]) + in[3] * tp[2];
+++ for (i = 0; i < n_2_ccomplex_blocks; ++i) {
+++ sum0[0] += in[0] * tp[0] + in[1] * tp[1];
+++ sum0[1] += (-in[0] * tp[1]) + in[1] * tp[0];
+++ sum1[0] += in[2] * tp[2] + in[3] * tp[3];
+++ sum1[1] += (-in[2] * tp[3]) + in[3] * tp[2];
++
++- in += 4;
++- tp += 4;
++- }
+++ in += 4;
+++ tp += 4;
+++ }
++
++- res[0] = sum0[0] + sum1[0];
++- res[1] = sum0[1] + sum1[1];
+++ res[0] = sum0[0] + sum1[0];
+++ res[1] = sum0[1] + sum1[1];
++
++- if (num_bytes >> 3 & 1) {
++- *result += input[(num_bytes >> 3) - 1] * lv_conj(taps[(num_bytes >> 3) - 1]);
++- }
+++ if (num_bytes >> 3 & 1) {
+++ *result += input[(num_bytes >> 3) - 1] * lv_conj(taps[(num_bytes >> 3) - 1]);
+++ }
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -103,125 +107,134 @@ static inline void volk_32fc_x2_conjugate_dot_prod_32fc_generic(lv_32fc_t* resul
++ #include <immintrin.h>
++
++ static inline void volk_32fc_x2_conjugate_dot_prod_32fc_u_avx(lv_32fc_t* result,
++- const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points)
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
++ {
++- // Partial sums for indices i, i+1, i+2 and i+3.
++- __m256 sum_a_mult_b_real = _mm256_setzero_ps();
++- __m256 sum_a_mult_b_imag = _mm256_setzero_ps();
++-
++- for (long unsigned i = 0; i < (num_points & ~3u); i += 4) {
++- /* Four complex elements a time are processed.
++- * (ar + jâ‹…ai)*conj(br + jâ‹…bi) =
++- * ar⋅br + ai⋅bi + j⋅(ai⋅br − ar⋅bi)
++- */
+++ // Partial sums for indices i, i+1, i+2 and i+3.
+++ __m256 sum_a_mult_b_real = _mm256_setzero_ps();
+++ __m256 sum_a_mult_b_imag = _mm256_setzero_ps();
+++
+++ for (long unsigned i = 0; i < (num_points & ~3u); i += 4) {
+++ /* Four complex elements a time are processed.
+++ * (ar + jâ‹…ai)*conj(br + jâ‹…bi) =
+++ * ar⋅br + ai⋅bi + j⋅(ai⋅br − ar⋅bi)
+++ */
+++
+++ /* Load input and taps, split and duplicate real und imaginary parts of taps.
+++ * a: | ai,i+3 | ar,i+3 | … | ai,i+1 | ar,i+1 | ai,i+0 | ar,i+0 |
+++ * b: | bi,i+3 | br,i+3 | … | bi,i+1 | br,i+1 | bi,i+0 | br,i+0 |
+++ * b_real: | br,i+3 | br,i+3 | … | br,i+1 | br,i+1 | br,i+0 | br,i+0 |
+++ * b_imag: | bi,i+3 | bi,i+3 | … | bi,i+1 | bi,i+1 | bi,i+0 | bi,i+0 |
+++ */
+++ __m256 a = _mm256_loadu_ps((const float*)&input[i]);
+++ __m256 b = _mm256_loadu_ps((const float*)&taps[i]);
+++ __m256 b_real = _mm256_moveldup_ps(b);
+++ __m256 b_imag = _mm256_movehdup_ps(b);
+++
+++ // Add | ai⋅br,i+3 | ar⋅br,i+3 | … | ai⋅br,i+0 | ar⋅br,i+0 | to partial sum.
+++ sum_a_mult_b_real = _mm256_add_ps(sum_a_mult_b_real, _mm256_mul_ps(a, b_real));
+++ // Add | ai⋅bi,i+3 | −ar⋅bi,i+3 | … | ai⋅bi,i+0 | −ar⋅bi,i+0 | to partial sum.
+++ sum_a_mult_b_imag = _mm256_addsub_ps(sum_a_mult_b_imag, _mm256_mul_ps(a, b_imag));
+++ }
++
++- /* Load input and taps, split and duplicate real und imaginary parts of taps.
++- * a: | ai,i+3 | ar,i+3 | … | ai,i+1 | ar,i+1 | ai,i+0 | ar,i+0 |
++- * b: | bi,i+3 | br,i+3 | … | bi,i+1 | br,i+1 | bi,i+0 | br,i+0 |
++- * b_real: | br,i+3 | br,i+3 | … | br,i+1 | br,i+1 | br,i+0 | br,i+0 |
++- * b_imag: | bi,i+3 | bi,i+3 | … | bi,i+1 | bi,i+1 | bi,i+0 | bi,i+0 |
+++ // Swap position of −ar⋅bi and ai⋅bi.
+++ sum_a_mult_b_imag = _mm256_permute_ps(sum_a_mult_b_imag, _MM_SHUFFLE(2, 3, 0, 1));
+++ // | ai⋅br + ai⋅bi | ai⋅br − ar⋅bi |, sum contains four such partial sums.
+++ __m256 sum = _mm256_add_ps(sum_a_mult_b_real, sum_a_mult_b_imag);
+++ /* Sum the four partial sums: Add high half of vector sum to the low one, i.e.
+++ * s1 + s3 and s0 + s2 …
++ */
++- __m256 a = _mm256_loadu_ps((const float *) &input[i]);
++- __m256 b = _mm256_loadu_ps((const float *) &taps[i]);
++- __m256 b_real = _mm256_moveldup_ps(b);
++- __m256 b_imag = _mm256_movehdup_ps(b);
++-
++- // Add | ai⋅br,i+3 | ar⋅br,i+3 | … | ai⋅br,i+0 | ar⋅br,i+0 | to partial sum.
++- sum_a_mult_b_real = _mm256_add_ps(sum_a_mult_b_real, _mm256_mul_ps(a, b_real));
++- // Add | ai⋅bi,i+3 | −ar⋅bi,i+3 | … | ai⋅bi,i+0 | −ar⋅bi,i+0 | to partial sum.
++- sum_a_mult_b_imag = _mm256_addsub_ps(sum_a_mult_b_imag, _mm256_mul_ps(a, b_imag));
++- }
++-
++- // Swap position of −ar⋅bi and ai⋅bi.
++- sum_a_mult_b_imag = _mm256_permute_ps(sum_a_mult_b_imag, _MM_SHUFFLE(2, 3, 0, 1));
++- // | ai⋅br + ai⋅bi | ai⋅br − ar⋅bi |, sum contains four such partial sums.
++- __m256 sum = _mm256_add_ps(sum_a_mult_b_real, sum_a_mult_b_imag);
++- /* Sum the four partial sums: Add high half of vector sum to the low one, i.e.
++- * s1 + s3 and s0 + s2 …
++- */
++- sum = _mm256_add_ps(sum, _mm256_permute2f128_ps(sum, sum, 0x01));
++- // … and now (s0 + s2) + (s1 + s3)
++- sum = _mm256_add_ps(sum, _mm256_permute_ps(sum, _MM_SHUFFLE(1, 0, 3, 2)));
++- // Store result.
++- __m128 lower = _mm256_extractf128_ps(sum, 0);
++- _mm_storel_pi((__m64 *) result, lower);
++-
++- // Handle the last elements if num_points mod 4 is bigger than 0.
++- for (long unsigned i = num_points & ~3u; i < num_points; ++i) {
++- *result += lv_cmake(
++- lv_creal(input[i]) * lv_creal(taps[i]) + lv_cimag(input[i]) * lv_cimag(taps[i]),
++- lv_cimag(input[i]) * lv_creal(taps[i]) - lv_creal(input[i]) * lv_cimag(taps[i]));
++- }
+++ sum = _mm256_add_ps(sum, _mm256_permute2f128_ps(sum, sum, 0x01));
+++ // … and now (s0 + s2) + (s1 + s3)
+++ sum = _mm256_add_ps(sum, _mm256_permute_ps(sum, _MM_SHUFFLE(1, 0, 3, 2)));
+++ // Store result.
+++ __m128 lower = _mm256_extractf128_ps(sum, 0);
+++ _mm_storel_pi((__m64*)result, lower);
+++
+++ // Handle the last elements if num_points mod 4 is bigger than 0.
+++ for (long unsigned i = num_points & ~3u; i < num_points; ++i) {
+++ *result += lv_cmake(lv_creal(input[i]) * lv_creal(taps[i]) +
+++ lv_cimag(input[i]) * lv_cimag(taps[i]),
+++ lv_cimag(input[i]) * lv_creal(taps[i]) -
+++ lv_creal(input[i]) * lv_cimag(taps[i]));
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE3
++
++-#include <xmmintrin.h>
++ #include <pmmintrin.h>
+++#include <xmmintrin.h>
++
++ static inline void volk_32fc_x2_conjugate_dot_prod_32fc_u_sse3(lv_32fc_t* result,
++- const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points)
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
++ {
++- // Partial sums for indices i and i+1.
++- __m128 sum_a_mult_b_real = _mm_setzero_ps();
++- __m128 sum_a_mult_b_imag = _mm_setzero_ps();
++-
++- for (long unsigned i = 0; i < (num_points & ~1u); i += 2) {
++- /* Two complex elements a time are processed.
++- * (ar + jâ‹…ai)*conj(br + jâ‹…bi) =
++- * ar⋅br + ai⋅bi + j⋅(ai⋅br − ar⋅bi)
++- */
+++ // Partial sums for indices i and i+1.
+++ __m128 sum_a_mult_b_real = _mm_setzero_ps();
+++ __m128 sum_a_mult_b_imag = _mm_setzero_ps();
+++
+++ for (long unsigned i = 0; i < (num_points & ~1u); i += 2) {
+++ /* Two complex elements a time are processed.
+++ * (ar + jâ‹…ai)*conj(br + jâ‹…bi) =
+++ * ar⋅br + ai⋅bi + j⋅(ai⋅br − ar⋅bi)
+++ */
+++
+++ /* Load input and taps, split and duplicate real und imaginary parts of taps.
+++ * a: | ai,i+1 | ar,i+1 | ai,i+0 | ar,i+0 |
+++ * b: | bi,i+1 | br,i+1 | bi,i+0 | br,i+0 |
+++ * b_real: | br,i+1 | br,i+1 | br,i+0 | br,i+0 |
+++ * b_imag: | bi,i+1 | bi,i+1 | bi,i+0 | bi,i+0 |
+++ */
+++ __m128 a = _mm_loadu_ps((const float*)&input[i]);
+++ __m128 b = _mm_loadu_ps((const float*)&taps[i]);
+++ __m128 b_real = _mm_moveldup_ps(b);
+++ __m128 b_imag = _mm_movehdup_ps(b);
+++
+++ // Add | aiâ‹…br,i+1 | arâ‹…br,i+1 | aiâ‹…br,i+0 | arâ‹…br,i+0 | to partial sum.
+++ sum_a_mult_b_real = _mm_add_ps(sum_a_mult_b_real, _mm_mul_ps(a, b_real));
+++ // Add | ai⋅bi,i+1 | −ar⋅bi,i+1 | ai⋅bi,i+0 | −ar⋅bi,i+0 | to partial sum.
+++ sum_a_mult_b_imag = _mm_addsub_ps(sum_a_mult_b_imag, _mm_mul_ps(a, b_imag));
+++ }
++
++- /* Load input and taps, split and duplicate real und imaginary parts of taps.
++- * a: | ai,i+1 | ar,i+1 | ai,i+0 | ar,i+0 |
++- * b: | bi,i+1 | br,i+1 | bi,i+0 | br,i+0 |
++- * b_real: | br,i+1 | br,i+1 | br,i+0 | br,i+0 |
++- * b_imag: | bi,i+1 | bi,i+1 | bi,i+0 | bi,i+0 |
++- */
++- __m128 a = _mm_loadu_ps((const float *) &input[i]);
++- __m128 b = _mm_loadu_ps((const float *) &taps[i]);
++- __m128 b_real = _mm_moveldup_ps(b);
++- __m128 b_imag = _mm_movehdup_ps(b);
++-
++- // Add | aiâ‹…br,i+1 | arâ‹…br,i+1 | aiâ‹…br,i+0 | arâ‹…br,i+0 | to partial sum.
++- sum_a_mult_b_real = _mm_add_ps(sum_a_mult_b_real, _mm_mul_ps(a, b_real));
++- // Add | ai⋅bi,i+1 | −ar⋅bi,i+1 | ai⋅bi,i+0 | −ar⋅bi,i+0 | to partial sum.
++- sum_a_mult_b_imag = _mm_addsub_ps(sum_a_mult_b_imag, _mm_mul_ps(a, b_imag));
++- }
++-
++- // Swap position of −ar⋅bi and ai⋅bi.
++- sum_a_mult_b_imag = _mm_shuffle_ps(sum_a_mult_b_imag, sum_a_mult_b_imag,
++- _MM_SHUFFLE(2, 3, 0, 1));
++- // | ai⋅br + ai⋅bi | ai⋅br − ar⋅bi |, sum contains two such partial sums.
++- __m128 sum = _mm_add_ps(sum_a_mult_b_real, sum_a_mult_b_imag);
++- // Sum the two partial sums.
++- sum = _mm_add_ps(sum, _mm_shuffle_ps(sum, sum, _MM_SHUFFLE(1, 0, 3, 2)));
++- // Store result.
++- _mm_storel_pi((__m64 *) result, sum);
++-
++- // Handle the last element if num_points mod 2 is 1.
++- if (num_points & 1u) {
++- *result += lv_cmake(
++- lv_creal(input[num_points - 1]) * lv_creal(taps[num_points - 1]) +
++- lv_cimag(input[num_points - 1]) * lv_cimag(taps[num_points - 1]),
++- lv_cimag(input[num_points - 1]) * lv_creal(taps[num_points - 1]) -
++- lv_creal(input[num_points - 1]) * lv_cimag(taps[num_points - 1]));
++- }
+++ // Swap position of −ar⋅bi and ai⋅bi.
+++ sum_a_mult_b_imag =
+++ _mm_shuffle_ps(sum_a_mult_b_imag, sum_a_mult_b_imag, _MM_SHUFFLE(2, 3, 0, 1));
+++ // | ai⋅br + ai⋅bi | ai⋅br − ar⋅bi |, sum contains two such partial sums.
+++ __m128 sum = _mm_add_ps(sum_a_mult_b_real, sum_a_mult_b_imag);
+++ // Sum the two partial sums.
+++ sum = _mm_add_ps(sum, _mm_shuffle_ps(sum, sum, _MM_SHUFFLE(1, 0, 3, 2)));
+++ // Store result.
+++ _mm_storel_pi((__m64*)result, sum);
+++
+++ // Handle the last element if num_points mod 2 is 1.
+++ if (num_points & 1u) {
+++ *result += lv_cmake(
+++ lv_creal(input[num_points - 1]) * lv_creal(taps[num_points - 1]) +
+++ lv_cimag(input[num_points - 1]) * lv_cimag(taps[num_points - 1]),
+++ lv_cimag(input[num_points - 1]) * lv_creal(taps[num_points - 1]) -
+++ lv_creal(input[num_points - 1]) * lv_cimag(taps[num_points - 1]));
+++ }
++ }
++
++ #endif /*LV_HAVE_SSE3*/
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++-static inline void volk_32fc_x2_conjugate_dot_prod_32fc_neon(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_conjugate_dot_prod_32fc_neon(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++ unsigned int quarter_points = num_points / 4;
++ unsigned int number;
++
++- lv_32fc_t* a_ptr = (lv_32fc_t*) taps;
++- lv_32fc_t* b_ptr = (lv_32fc_t*) input;
+++ lv_32fc_t* a_ptr = (lv_32fc_t*)taps;
+++ lv_32fc_t* b_ptr = (lv_32fc_t*)input;
++ // for 2-lane vectors, 1st lane holds the real part,
++ // 2nd lane holds the imaginary part
++ float32x4x2_t a_val, b_val, accumulator;
++@@ -229,11 +242,11 @@ static inline void volk_32fc_x2_conjugate_dot_prod_32fc_neon(lv_32fc_t* result,
++ accumulator.val[0] = vdupq_n_f32(0);
++ accumulator.val[1] = vdupq_n_f32(0);
++
++- for(number = 0; number < quarter_points; ++number) {
+++ for (number = 0; number < quarter_points; ++number) {
++ a_val = vld2q_f32((float*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
++ b_val = vld2q_f32((float*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
++- __VOLK_PREFETCH(a_ptr+8);
++- __VOLK_PREFETCH(b_ptr+8);
+++ __VOLK_PREFETCH(a_ptr + 8);
+++ __VOLK_PREFETCH(b_ptr + 8);
++
++ // do the first multiply
++ tmp_imag.val[1] = vmulq_f32(a_val.val[1], b_val.val[0]);
++@@ -255,11 +268,10 @@ static inline void volk_32fc_x2_conjugate_dot_prod_32fc_neon(lv_32fc_t* result,
++ *result = accum_result[0] + accum_result[1] + accum_result[2] + accum_result[3];
++
++ // tail case
++- for(number = quarter_points*4; number < num_points; ++number) {
++- *result += (*a_ptr++) * lv_conj(*b_ptr++);
+++ for (number = quarter_points * 4; number < num_points; ++number) {
+++ *result += (*a_ptr++) * lv_conj(*b_ptr++);
++ }
++ *result = lv_conj(*result);
++-
++ }
++ #endif /*LV_HAVE_NEON*/
++
++@@ -268,120 +280,125 @@ static inline void volk_32fc_x2_conjugate_dot_prod_32fc_neon(lv_32fc_t* result,
++ #ifndef INCLUDED_volk_32fc_x2_conjugate_dot_prod_32fc_a_H
++ #define INCLUDED_volk_32fc_x2_conjugate_dot_prod_32fc_a_H
++
+++#include <stdio.h>
++ #include <volk/volk_common.h>
++-#include<volk/volk_complex.h>
++-#include<stdio.h>
+++#include <volk/volk_complex.h>
++
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++ static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_avx(lv_32fc_t* result,
++- const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points)
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
++ {
++- // Partial sums for indices i, i+1, i+2 and i+3.
++- __m256 sum_a_mult_b_real = _mm256_setzero_ps();
++- __m256 sum_a_mult_b_imag = _mm256_setzero_ps();
++-
++- for (long unsigned i = 0; i < (num_points & ~3u); i += 4) {
++- /* Four complex elements a time are processed.
++- * (ar + jâ‹…ai)*conj(br + jâ‹…bi) =
++- * ar⋅br + ai⋅bi + j⋅(ai⋅br − ar⋅bi)
++- */
+++ // Partial sums for indices i, i+1, i+2 and i+3.
+++ __m256 sum_a_mult_b_real = _mm256_setzero_ps();
+++ __m256 sum_a_mult_b_imag = _mm256_setzero_ps();
+++
+++ for (long unsigned i = 0; i < (num_points & ~3u); i += 4) {
+++ /* Four complex elements a time are processed.
+++ * (ar + jâ‹…ai)*conj(br + jâ‹…bi) =
+++ * ar⋅br + ai⋅bi + j⋅(ai⋅br − ar⋅bi)
+++ */
+++
+++ /* Load input and taps, split and duplicate real und imaginary parts of taps.
+++ * a: | ai,i+3 | ar,i+3 | … | ai,i+1 | ar,i+1 | ai,i+0 | ar,i+0 |
+++ * b: | bi,i+3 | br,i+3 | … | bi,i+1 | br,i+1 | bi,i+0 | br,i+0 |
+++ * b_real: | br,i+3 | br,i+3 | … | br,i+1 | br,i+1 | br,i+0 | br,i+0 |
+++ * b_imag: | bi,i+3 | bi,i+3 | … | bi,i+1 | bi,i+1 | bi,i+0 | bi,i+0 |
+++ */
+++ __m256 a = _mm256_load_ps((const float*)&input[i]);
+++ __m256 b = _mm256_load_ps((const float*)&taps[i]);
+++ __m256 b_real = _mm256_moveldup_ps(b);
+++ __m256 b_imag = _mm256_movehdup_ps(b);
+++
+++ // Add | ai⋅br,i+3 | ar⋅br,i+3 | … | ai⋅br,i+0 | ar⋅br,i+0 | to partial sum.
+++ sum_a_mult_b_real = _mm256_add_ps(sum_a_mult_b_real, _mm256_mul_ps(a, b_real));
+++ // Add | ai⋅bi,i+3 | −ar⋅bi,i+3 | … | ai⋅bi,i+0 | −ar⋅bi,i+0 | to partial sum.
+++ sum_a_mult_b_imag = _mm256_addsub_ps(sum_a_mult_b_imag, _mm256_mul_ps(a, b_imag));
+++ }
++
++- /* Load input and taps, split and duplicate real und imaginary parts of taps.
++- * a: | ai,i+3 | ar,i+3 | … | ai,i+1 | ar,i+1 | ai,i+0 | ar,i+0 |
++- * b: | bi,i+3 | br,i+3 | … | bi,i+1 | br,i+1 | bi,i+0 | br,i+0 |
++- * b_real: | br,i+3 | br,i+3 | … | br,i+1 | br,i+1 | br,i+0 | br,i+0 |
++- * b_imag: | bi,i+3 | bi,i+3 | … | bi,i+1 | bi,i+1 | bi,i+0 | bi,i+0 |
+++ // Swap position of −ar⋅bi and ai⋅bi.
+++ sum_a_mult_b_imag = _mm256_permute_ps(sum_a_mult_b_imag, _MM_SHUFFLE(2, 3, 0, 1));
+++ // | ai⋅br + ai⋅bi | ai⋅br − ar⋅bi |, sum contains four such partial sums.
+++ __m256 sum = _mm256_add_ps(sum_a_mult_b_real, sum_a_mult_b_imag);
+++ /* Sum the four partial sums: Add high half of vector sum to the low one, i.e.
+++ * s1 + s3 and s0 + s2 …
++ */
++- __m256 a = _mm256_load_ps((const float *) &input[i]);
++- __m256 b = _mm256_load_ps((const float *) &taps[i]);
++- __m256 b_real = _mm256_moveldup_ps(b);
++- __m256 b_imag = _mm256_movehdup_ps(b);
++-
++- // Add | ai⋅br,i+3 | ar⋅br,i+3 | … | ai⋅br,i+0 | ar⋅br,i+0 | to partial sum.
++- sum_a_mult_b_real = _mm256_add_ps(sum_a_mult_b_real, _mm256_mul_ps(a, b_real));
++- // Add | ai⋅bi,i+3 | −ar⋅bi,i+3 | … | ai⋅bi,i+0 | −ar⋅bi,i+0 | to partial sum.
++- sum_a_mult_b_imag = _mm256_addsub_ps(sum_a_mult_b_imag, _mm256_mul_ps(a, b_imag));
++- }
++-
++- // Swap position of −ar⋅bi and ai⋅bi.
++- sum_a_mult_b_imag = _mm256_permute_ps(sum_a_mult_b_imag, _MM_SHUFFLE(2, 3, 0, 1));
++- // | ai⋅br + ai⋅bi | ai⋅br − ar⋅bi |, sum contains four such partial sums.
++- __m256 sum = _mm256_add_ps(sum_a_mult_b_real, sum_a_mult_b_imag);
++- /* Sum the four partial sums: Add high half of vector sum to the low one, i.e.
++- * s1 + s3 and s0 + s2 …
++- */
++- sum = _mm256_add_ps(sum, _mm256_permute2f128_ps(sum, sum, 0x01));
++- // … and now (s0 + s2) + (s1 + s3)
++- sum = _mm256_add_ps(sum, _mm256_permute_ps(sum, _MM_SHUFFLE(1, 0, 3, 2)));
++- // Store result.
++- __m128 lower = _mm256_extractf128_ps(sum, 0);
++- _mm_storel_pi((__m64 *) result, lower);
++-
++- // Handle the last elements if num_points mod 4 is bigger than 0.
++- for (long unsigned i = num_points & ~3u; i < num_points; ++i) {
++- *result += lv_cmake(
++- lv_creal(input[i]) * lv_creal(taps[i]) + lv_cimag(input[i]) * lv_cimag(taps[i]),
++- lv_cimag(input[i]) * lv_creal(taps[i]) - lv_creal(input[i]) * lv_cimag(taps[i]));
++- }
+++ sum = _mm256_add_ps(sum, _mm256_permute2f128_ps(sum, sum, 0x01));
+++ // … and now (s0 + s2) + (s1 + s3)
+++ sum = _mm256_add_ps(sum, _mm256_permute_ps(sum, _MM_SHUFFLE(1, 0, 3, 2)));
+++ // Store result.
+++ __m128 lower = _mm256_extractf128_ps(sum, 0);
+++ _mm_storel_pi((__m64*)result, lower);
+++
+++ // Handle the last elements if num_points mod 4 is bigger than 0.
+++ for (long unsigned i = num_points & ~3u; i < num_points; ++i) {
+++ *result += lv_cmake(lv_creal(input[i]) * lv_creal(taps[i]) +
+++ lv_cimag(input[i]) * lv_cimag(taps[i]),
+++ lv_cimag(input[i]) * lv_creal(taps[i]) -
+++ lv_creal(input[i]) * lv_cimag(taps[i]));
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_SSE3
++
++-#include <xmmintrin.h>
++ #include <pmmintrin.h>
+++#include <xmmintrin.h>
++
++ static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_sse3(lv_32fc_t* result,
++- const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points)
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
++ {
++- // Partial sums for indices i and i+1.
++- __m128 sum_a_mult_b_real = _mm_setzero_ps();
++- __m128 sum_a_mult_b_imag = _mm_setzero_ps();
++-
++- for (long unsigned i = 0; i < (num_points & ~1u); i += 2) {
++- /* Two complex elements a time are processed.
++- * (ar + jâ‹…ai)*conj(br + jâ‹…bi) =
++- * ar⋅br + ai⋅bi + j⋅(ai⋅br − ar⋅bi)
++- */
+++ // Partial sums for indices i and i+1.
+++ __m128 sum_a_mult_b_real = _mm_setzero_ps();
+++ __m128 sum_a_mult_b_imag = _mm_setzero_ps();
+++
+++ for (long unsigned i = 0; i < (num_points & ~1u); i += 2) {
+++ /* Two complex elements a time are processed.
+++ * (ar + jâ‹…ai)*conj(br + jâ‹…bi) =
+++ * ar⋅br + ai⋅bi + j⋅(ai⋅br − ar⋅bi)
+++ */
+++
+++ /* Load input and taps, split and duplicate real und imaginary parts of taps.
+++ * a: | ai,i+1 | ar,i+1 | ai,i+0 | ar,i+0 |
+++ * b: | bi,i+1 | br,i+1 | bi,i+0 | br,i+0 |
+++ * b_real: | br,i+1 | br,i+1 | br,i+0 | br,i+0 |
+++ * b_imag: | bi,i+1 | bi,i+1 | bi,i+0 | bi,i+0 |
+++ */
+++ __m128 a = _mm_load_ps((const float*)&input[i]);
+++ __m128 b = _mm_load_ps((const float*)&taps[i]);
+++ __m128 b_real = _mm_moveldup_ps(b);
+++ __m128 b_imag = _mm_movehdup_ps(b);
+++
+++ // Add | aiâ‹…br,i+1 | arâ‹…br,i+1 | aiâ‹…br,i+0 | arâ‹…br,i+0 | to partial sum.
+++ sum_a_mult_b_real = _mm_add_ps(sum_a_mult_b_real, _mm_mul_ps(a, b_real));
+++ // Add | ai⋅bi,i+1 | −ar⋅bi,i+1 | ai⋅bi,i+0 | −ar⋅bi,i+0 | to partial sum.
+++ sum_a_mult_b_imag = _mm_addsub_ps(sum_a_mult_b_imag, _mm_mul_ps(a, b_imag));
+++ }
++
++- /* Load input and taps, split and duplicate real und imaginary parts of taps.
++- * a: | ai,i+1 | ar,i+1 | ai,i+0 | ar,i+0 |
++- * b: | bi,i+1 | br,i+1 | bi,i+0 | br,i+0 |
++- * b_real: | br,i+1 | br,i+1 | br,i+0 | br,i+0 |
++- * b_imag: | bi,i+1 | bi,i+1 | bi,i+0 | bi,i+0 |
++- */
++- __m128 a = _mm_load_ps((const float *) &input[i]);
++- __m128 b = _mm_load_ps((const float *) &taps[i]);
++- __m128 b_real = _mm_moveldup_ps(b);
++- __m128 b_imag = _mm_movehdup_ps(b);
++-
++- // Add | aiâ‹…br,i+1 | arâ‹…br,i+1 | aiâ‹…br,i+0 | arâ‹…br,i+0 | to partial sum.
++- sum_a_mult_b_real = _mm_add_ps(sum_a_mult_b_real, _mm_mul_ps(a, b_real));
++- // Add | ai⋅bi,i+1 | −ar⋅bi,i+1 | ai⋅bi,i+0 | −ar⋅bi,i+0 | to partial sum.
++- sum_a_mult_b_imag = _mm_addsub_ps(sum_a_mult_b_imag, _mm_mul_ps(a, b_imag));
++- }
++-
++- // Swap position of −ar⋅bi and ai⋅bi.
++- sum_a_mult_b_imag = _mm_shuffle_ps(sum_a_mult_b_imag, sum_a_mult_b_imag,
++- _MM_SHUFFLE(2, 3, 0, 1));
++- // | ai⋅br + ai⋅bi | ai⋅br − ar⋅bi |, sum contains two such partial sums.
++- __m128 sum = _mm_add_ps(sum_a_mult_b_real, sum_a_mult_b_imag);
++- // Sum the two partial sums.
++- sum = _mm_add_ps(sum, _mm_shuffle_ps(sum, sum, _MM_SHUFFLE(1, 0, 3, 2)));
++- // Store result.
++- _mm_storel_pi((__m64 *) result, sum);
++-
++- // Handle the last element if num_points mod 2 is 1.
++- if (num_points & 1u) {
++- *result += lv_cmake(
++- lv_creal(input[num_points - 1]) * lv_creal(taps[num_points - 1]) +
++- lv_cimag(input[num_points - 1]) * lv_cimag(taps[num_points - 1]),
++- lv_cimag(input[num_points - 1]) * lv_creal(taps[num_points - 1]) -
++- lv_creal(input[num_points - 1]) * lv_cimag(taps[num_points - 1]));
++- }
+++ // Swap position of −ar⋅bi and ai⋅bi.
+++ sum_a_mult_b_imag =
+++ _mm_shuffle_ps(sum_a_mult_b_imag, sum_a_mult_b_imag, _MM_SHUFFLE(2, 3, 0, 1));
+++ // | ai⋅br + ai⋅bi | ai⋅br − ar⋅bi |, sum contains two such partial sums.
+++ __m128 sum = _mm_add_ps(sum_a_mult_b_real, sum_a_mult_b_imag);
+++ // Sum the two partial sums.
+++ sum = _mm_add_ps(sum, _mm_shuffle_ps(sum, sum, _MM_SHUFFLE(1, 0, 3, 2)));
+++ // Store result.
+++ _mm_storel_pi((__m64*)result, sum);
+++
+++ // Handle the last element if num_points mod 2 is 1.
+++ if (num_points & 1u) {
+++ *result += lv_cmake(
+++ lv_creal(input[num_points - 1]) * lv_creal(taps[num_points - 1]) +
+++ lv_cimag(input[num_points - 1]) * lv_cimag(taps[num_points - 1]),
+++ lv_cimag(input[num_points - 1]) * lv_creal(taps[num_points - 1]) -
+++ lv_creal(input[num_points - 1]) * lv_cimag(taps[num_points - 1]));
+++ }
++ }
++
++ #endif /*LV_HAVE_SSE3*/
++@@ -390,35 +407,39 @@ static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_sse3(lv_32fc_t* result
++ #ifdef LV_HAVE_GENERIC
++
++
++-static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_generic(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- const unsigned int num_bytes = num_points*8;
+++ const unsigned int num_bytes = num_points * 8;
++
++- float * res = (float*) result;
++- float * in = (float*) input;
++- float * tp = (float*) taps;
++- unsigned int n_2_ccomplex_blocks = num_bytes >> 4;
+++ float* res = (float*)result;
+++ float* in = (float*)input;
+++ float* tp = (float*)taps;
+++ unsigned int n_2_ccomplex_blocks = num_bytes >> 4;
++
++- float sum0[2] = {0,0};
++- float sum1[2] = {0,0};
++- unsigned int i = 0;
+++ float sum0[2] = { 0, 0 };
+++ float sum1[2] = { 0, 0 };
+++ unsigned int i = 0;
++
++- for(i = 0; i < n_2_ccomplex_blocks; ++i) {
++- sum0[0] += in[0] * tp[0] + in[1] * tp[1];
++- sum0[1] += (-in[0] * tp[1]) + in[1] * tp[0];
++- sum1[0] += in[2] * tp[2] + in[3] * tp[3];
++- sum1[1] += (-in[2] * tp[3]) + in[3] * tp[2];
+++ for (i = 0; i < n_2_ccomplex_blocks; ++i) {
+++ sum0[0] += in[0] * tp[0] + in[1] * tp[1];
+++ sum0[1] += (-in[0] * tp[1]) + in[1] * tp[0];
+++ sum1[0] += in[2] * tp[2] + in[3] * tp[3];
+++ sum1[1] += (-in[2] * tp[3]) + in[3] * tp[2];
++
++- in += 4;
++- tp += 4;
++- }
+++ in += 4;
+++ tp += 4;
+++ }
++
++- res[0] = sum0[0] + sum1[0];
++- res[1] = sum0[1] + sum1[1];
+++ res[0] = sum0[0] + sum1[0];
+++ res[1] = sum0[1] + sum1[1];
++
++- if (num_bytes >> 3 & 1) {
++- *result += input[(num_bytes >> 3) - 1] * lv_conj(taps[(num_bytes >> 3) - 1]);
++- }
+++ if (num_bytes >> 3 & 1) {
+++ *result += input[(num_bytes >> 3) - 1] * lv_conj(taps[(num_bytes >> 3) - 1]);
+++ }
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -426,256 +447,276 @@ static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_generic(lv_32fc_t* res
++
++ #if LV_HAVE_SSE && LV_HAVE_64
++
++-static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_sse(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
++-
++- const unsigned int num_bytes = num_points*8;
++-
++- __VOLK_ATTR_ALIGNED(16) static const uint32_t conjugator[4]= {0x00000000, 0x80000000, 0x00000000, 0x80000000};
++-
++- __VOLK_ASM __VOLK_VOLATILE
++- (
++- "# ccomplex_conjugate_dotprod_generic (float* result, const float *input,\n\t"
++- "# const float *taps, unsigned num_bytes)\n\t"
++- "# float sum0 = 0;\n\t"
++- "# float sum1 = 0;\n\t"
++- "# float sum2 = 0;\n\t"
++- "# float sum3 = 0;\n\t"
++- "# do {\n\t"
++- "# sum0 += input[0] * taps[0] - input[1] * taps[1];\n\t"
++- "# sum1 += input[0] * taps[1] + input[1] * taps[0];\n\t"
++- "# sum2 += input[2] * taps[2] - input[3] * taps[3];\n\t"
++- "# sum3 += input[2] * taps[3] + input[3] * taps[2];\n\t"
++- "# input += 4;\n\t"
++- "# taps += 4; \n\t"
++- "# } while (--n_2_ccomplex_blocks != 0);\n\t"
++- "# result[0] = sum0 + sum2;\n\t"
++- "# result[1] = sum1 + sum3;\n\t"
++- "# TODO: prefetch and better scheduling\n\t"
++- " xor %%r9, %%r9\n\t"
++- " xor %%r10, %%r10\n\t"
++- " movq %[conjugator], %%r9\n\t"
++- " movq %%rcx, %%rax\n\t"
++- " movaps 0(%%r9), %%xmm8\n\t"
++- " movq %%rcx, %%r8\n\t"
++- " movq %[rsi], %%r9\n\t"
++- " movq %[rdx], %%r10\n\t"
++- " xorps %%xmm6, %%xmm6 # zero accumulators\n\t"
++- " movaps 0(%%r9), %%xmm0\n\t"
++- " xorps %%xmm7, %%xmm7 # zero accumulators\n\t"
++- " movups 0(%%r10), %%xmm2\n\t"
++- " shr $5, %%rax # rax = n_2_ccomplex_blocks / 2\n\t"
++- " shr $4, %%r8\n\t"
++- " xorps %%xmm8, %%xmm2\n\t"
++- " jmp .%=L1_test\n\t"
++- " # 4 taps / loop\n\t"
++- " # something like ?? cycles / loop\n\t"
++- ".%=Loop1: \n\t"
++- "# complex prod: C += A * B, w/ temp Z & Y (or B), xmmPN=$0x8000000080000000\n\t"
++- "# movaps (%%r9), %%xmmA\n\t"
++- "# movaps (%%r10), %%xmmB\n\t"
++- "# movaps %%xmmA, %%xmmZ\n\t"
++- "# shufps $0xb1, %%xmmZ, %%xmmZ # swap internals\n\t"
++- "# mulps %%xmmB, %%xmmA\n\t"
++- "# mulps %%xmmZ, %%xmmB\n\t"
++- "# # SSE replacement for: pfpnacc %%xmmB, %%xmmA\n\t"
++- "# xorps %%xmmPN, %%xmmA\n\t"
++- "# movaps %%xmmA, %%xmmZ\n\t"
++- "# unpcklps %%xmmB, %%xmmA\n\t"
++- "# unpckhps %%xmmB, %%xmmZ\n\t"
++- "# movaps %%xmmZ, %%xmmY\n\t"
++- "# shufps $0x44, %%xmmA, %%xmmZ # b01000100\n\t"
++- "# shufps $0xee, %%xmmY, %%xmmA # b11101110\n\t"
++- "# addps %%xmmZ, %%xmmA\n\t"
++- "# addps %%xmmA, %%xmmC\n\t"
++- "# A=xmm0, B=xmm2, Z=xmm4\n\t"
++- "# A'=xmm1, B'=xmm3, Z'=xmm5\n\t"
++- " movaps 16(%%r9), %%xmm1\n\t"
++- " movaps %%xmm0, %%xmm4\n\t"
++- " mulps %%xmm2, %%xmm0\n\t"
++- " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
++- " movaps 16(%%r10), %%xmm3\n\t"
++- " movaps %%xmm1, %%xmm5\n\t"
++- " xorps %%xmm8, %%xmm3\n\t"
++- " addps %%xmm0, %%xmm6\n\t"
++- " mulps %%xmm3, %%xmm1\n\t"
++- " shufps $0xb1, %%xmm5, %%xmm5 # swap internals\n\t"
++- " addps %%xmm1, %%xmm6\n\t"
++- " mulps %%xmm4, %%xmm2\n\t"
++- " movaps 32(%%r9), %%xmm0\n\t"
++- " addps %%xmm2, %%xmm7\n\t"
++- " mulps %%xmm5, %%xmm3\n\t"
++- " add $32, %%r9\n\t"
++- " movaps 32(%%r10), %%xmm2\n\t"
++- " addps %%xmm3, %%xmm7\n\t"
++- " add $32, %%r10\n\t"
++- " xorps %%xmm8, %%xmm2\n\t"
++- ".%=L1_test:\n\t"
++- " dec %%rax\n\t"
++- " jge .%=Loop1\n\t"
++- " # We've handled the bulk of multiplies up to here.\n\t"
++- " # Let's sse if original n_2_ccomplex_blocks was odd.\n\t"
++- " # If so, we've got 2 more taps to do.\n\t"
++- " and $1, %%r8\n\t"
++- " je .%=Leven\n\t"
++- " # The count was odd, do 2 more taps.\n\t"
++- " # Note that we've already got mm0/mm2 preloaded\n\t"
++- " # from the main loop.\n\t"
++- " movaps %%xmm0, %%xmm4\n\t"
++- " mulps %%xmm2, %%xmm0\n\t"
++- " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
++- " addps %%xmm0, %%xmm6\n\t"
++- " mulps %%xmm4, %%xmm2\n\t"
++- " addps %%xmm2, %%xmm7\n\t"
++- ".%=Leven:\n\t"
++- " # neg inversor\n\t"
++- " xorps %%xmm1, %%xmm1\n\t"
++- " mov $0x80000000, %%r9\n\t"
++- " movd %%r9, %%xmm1\n\t"
++- " shufps $0x11, %%xmm1, %%xmm1 # b00010001 # 0 -0 0 -0\n\t"
++- " # pfpnacc\n\t"
++- " xorps %%xmm1, %%xmm6\n\t"
++- " movaps %%xmm6, %%xmm2\n\t"
++- " unpcklps %%xmm7, %%xmm6\n\t"
++- " unpckhps %%xmm7, %%xmm2\n\t"
++- " movaps %%xmm2, %%xmm3\n\t"
++- " shufps $0x44, %%xmm6, %%xmm2 # b01000100\n\t"
++- " shufps $0xee, %%xmm3, %%xmm6 # b11101110\n\t"
++- " addps %%xmm2, %%xmm6\n\t"
++- " # xmm6 = r1 i2 r3 i4\n\t"
++- " movhlps %%xmm6, %%xmm4 # xmm4 = r3 i4 ?? ??\n\t"
++- " addps %%xmm4, %%xmm6 # xmm6 = r1+r3 i2+i4 ?? ??\n\t"
++- " movlps %%xmm6, (%[rdi]) # store low 2x32 bits (complex) to memory\n\t"
++- :
++- :[rsi] "r" (input), [rdx] "r" (taps), "c" (num_bytes), [rdi] "r" (result), [conjugator] "r" (conjugator)
++- :"rax", "r8", "r9", "r10"
++- );
++-
++- int getem = num_bytes % 16;
++-
++- for(; getem > 0; getem -= 8) {
++- *result += (input[(num_bytes >> 3) - 1] * lv_conj(taps[(num_bytes >> 3) - 1]));
++- }
+++static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_sse(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
+++
+++ const unsigned int num_bytes = num_points * 8;
+++
+++ __VOLK_ATTR_ALIGNED(16)
+++ static const uint32_t conjugator[4] = {
+++ 0x00000000, 0x80000000, 0x00000000, 0x80000000
+++ };
+++
+++ __VOLK_ASM __VOLK_VOLATILE(
+++ "# ccomplex_conjugate_dotprod_generic (float* result, const float *input,\n\t"
+++ "# const float *taps, unsigned num_bytes)\n\t"
+++ "# float sum0 = 0;\n\t"
+++ "# float sum1 = 0;\n\t"
+++ "# float sum2 = 0;\n\t"
+++ "# float sum3 = 0;\n\t"
+++ "# do {\n\t"
+++ "# sum0 += input[0] * taps[0] - input[1] * taps[1];\n\t"
+++ "# sum1 += input[0] * taps[1] + input[1] * taps[0];\n\t"
+++ "# sum2 += input[2] * taps[2] - input[3] * taps[3];\n\t"
+++ "# sum3 += input[2] * taps[3] + input[3] * taps[2];\n\t"
+++ "# input += 4;\n\t"
+++ "# taps += 4; \n\t"
+++ "# } while (--n_2_ccomplex_blocks != 0);\n\t"
+++ "# result[0] = sum0 + sum2;\n\t"
+++ "# result[1] = sum1 + sum3;\n\t"
+++ "# TODO: prefetch and better scheduling\n\t"
+++ " xor %%r9, %%r9\n\t"
+++ " xor %%r10, %%r10\n\t"
+++ " movq %[conjugator], %%r9\n\t"
+++ " movq %%rcx, %%rax\n\t"
+++ " movaps 0(%%r9), %%xmm8\n\t"
+++ " movq %%rcx, %%r8\n\t"
+++ " movq %[rsi], %%r9\n\t"
+++ " movq %[rdx], %%r10\n\t"
+++ " xorps %%xmm6, %%xmm6 # zero accumulators\n\t"
+++ " movaps 0(%%r9), %%xmm0\n\t"
+++ " xorps %%xmm7, %%xmm7 # zero accumulators\n\t"
+++ " movups 0(%%r10), %%xmm2\n\t"
+++ " shr $5, %%rax # rax = n_2_ccomplex_blocks / 2\n\t"
+++ " shr $4, %%r8\n\t"
+++ " xorps %%xmm8, %%xmm2\n\t"
+++ " jmp .%=L1_test\n\t"
+++ " # 4 taps / loop\n\t"
+++ " # something like ?? cycles / loop\n\t"
+++ ".%=Loop1: \n\t"
+++ "# complex prod: C += A * B, w/ temp Z & Y (or B), xmmPN=$0x8000000080000000\n\t"
+++ "# movaps (%%r9), %%xmmA\n\t"
+++ "# movaps (%%r10), %%xmmB\n\t"
+++ "# movaps %%xmmA, %%xmmZ\n\t"
+++ "# shufps $0xb1, %%xmmZ, %%xmmZ # swap internals\n\t"
+++ "# mulps %%xmmB, %%xmmA\n\t"
+++ "# mulps %%xmmZ, %%xmmB\n\t"
+++ "# # SSE replacement for: pfpnacc %%xmmB, %%xmmA\n\t"
+++ "# xorps %%xmmPN, %%xmmA\n\t"
+++ "# movaps %%xmmA, %%xmmZ\n\t"
+++ "# unpcklps %%xmmB, %%xmmA\n\t"
+++ "# unpckhps %%xmmB, %%xmmZ\n\t"
+++ "# movaps %%xmmZ, %%xmmY\n\t"
+++ "# shufps $0x44, %%xmmA, %%xmmZ # b01000100\n\t"
+++ "# shufps $0xee, %%xmmY, %%xmmA # b11101110\n\t"
+++ "# addps %%xmmZ, %%xmmA\n\t"
+++ "# addps %%xmmA, %%xmmC\n\t"
+++ "# A=xmm0, B=xmm2, Z=xmm4\n\t"
+++ "# A'=xmm1, B'=xmm3, Z'=xmm5\n\t"
+++ " movaps 16(%%r9), %%xmm1\n\t"
+++ " movaps %%xmm0, %%xmm4\n\t"
+++ " mulps %%xmm2, %%xmm0\n\t"
+++ " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
+++ " movaps 16(%%r10), %%xmm3\n\t"
+++ " movaps %%xmm1, %%xmm5\n\t"
+++ " xorps %%xmm8, %%xmm3\n\t"
+++ " addps %%xmm0, %%xmm6\n\t"
+++ " mulps %%xmm3, %%xmm1\n\t"
+++ " shufps $0xb1, %%xmm5, %%xmm5 # swap internals\n\t"
+++ " addps %%xmm1, %%xmm6\n\t"
+++ " mulps %%xmm4, %%xmm2\n\t"
+++ " movaps 32(%%r9), %%xmm0\n\t"
+++ " addps %%xmm2, %%xmm7\n\t"
+++ " mulps %%xmm5, %%xmm3\n\t"
+++ " add $32, %%r9\n\t"
+++ " movaps 32(%%r10), %%xmm2\n\t"
+++ " addps %%xmm3, %%xmm7\n\t"
+++ " add $32, %%r10\n\t"
+++ " xorps %%xmm8, %%xmm2\n\t"
+++ ".%=L1_test:\n\t"
+++ " dec %%rax\n\t"
+++ " jge .%=Loop1\n\t"
+++ " # We've handled the bulk of multiplies up to here.\n\t"
+++ " # Let's sse if original n_2_ccomplex_blocks was odd.\n\t"
+++ " # If so, we've got 2 more taps to do.\n\t"
+++ " and $1, %%r8\n\t"
+++ " je .%=Leven\n\t"
+++ " # The count was odd, do 2 more taps.\n\t"
+++ " # Note that we've already got mm0/mm2 preloaded\n\t"
+++ " # from the main loop.\n\t"
+++ " movaps %%xmm0, %%xmm4\n\t"
+++ " mulps %%xmm2, %%xmm0\n\t"
+++ " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
+++ " addps %%xmm0, %%xmm6\n\t"
+++ " mulps %%xmm4, %%xmm2\n\t"
+++ " addps %%xmm2, %%xmm7\n\t"
+++ ".%=Leven:\n\t"
+++ " # neg inversor\n\t"
+++ " xorps %%xmm1, %%xmm1\n\t"
+++ " mov $0x80000000, %%r9\n\t"
+++ " movd %%r9, %%xmm1\n\t"
+++ " shufps $0x11, %%xmm1, %%xmm1 # b00010001 # 0 -0 0 -0\n\t"
+++ " # pfpnacc\n\t"
+++ " xorps %%xmm1, %%xmm6\n\t"
+++ " movaps %%xmm6, %%xmm2\n\t"
+++ " unpcklps %%xmm7, %%xmm6\n\t"
+++ " unpckhps %%xmm7, %%xmm2\n\t"
+++ " movaps %%xmm2, %%xmm3\n\t"
+++ " shufps $0x44, %%xmm6, %%xmm2 # b01000100\n\t"
+++ " shufps $0xee, %%xmm3, %%xmm6 # b11101110\n\t"
+++ " addps %%xmm2, %%xmm6\n\t"
+++ " # xmm6 = r1 i2 r3 i4\n\t"
+++ " movhlps %%xmm6, %%xmm4 # xmm4 = r3 i4 ?? ??\n\t"
+++ " addps %%xmm4, %%xmm6 # xmm6 = r1+r3 i2+i4 ?? ??\n\t"
+++ " movlps %%xmm6, (%[rdi]) # store low 2x32 bits (complex) "
+++ "to memory\n\t"
+++ :
+++ : [rsi] "r"(input),
+++ [rdx] "r"(taps),
+++ "c"(num_bytes),
+++ [rdi] "r"(result),
+++ [conjugator] "r"(conjugator)
+++ : "rax", "r8", "r9", "r10");
+++
+++ int getem = num_bytes % 16;
+++
+++ for (; getem > 0; getem -= 8) {
+++ *result += (input[(num_bytes >> 3) - 1] * lv_conj(taps[(num_bytes >> 3) - 1]));
+++ }
++ }
++ #endif
++
++ #if LV_HAVE_SSE && LV_HAVE_32
++-static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_sse_32(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
++-
++- const unsigned int num_bytes = num_points*8;
++-
++- __VOLK_ATTR_ALIGNED(16) static const uint32_t conjugator[4]= {0x00000000, 0x80000000, 0x00000000, 0x80000000};
++-
++- int bound = num_bytes >> 4;
++- int leftovers = num_bytes % 16;
++-
++- __VOLK_ASM __VOLK_VOLATILE
++- (
++- " #pushl %%ebp\n\t"
++- " #movl %%esp, %%ebp\n\t"
++- " #movl 12(%%ebp), %%eax # input\n\t"
++- " #movl 16(%%ebp), %%edx # taps\n\t"
++- " #movl 20(%%ebp), %%ecx # n_bytes\n\t"
++- " movaps 0(%[conjugator]), %%xmm1\n\t"
++- " xorps %%xmm6, %%xmm6 # zero accumulators\n\t"
++- " movaps 0(%[eax]), %%xmm0\n\t"
++- " xorps %%xmm7, %%xmm7 # zero accumulators\n\t"
++- " movaps 0(%[edx]), %%xmm2\n\t"
++- " movl %[ecx], (%[out])\n\t"
++- " shrl $5, %[ecx] # ecx = n_2_ccomplex_blocks / 2\n\t"
++-
++- " xorps %%xmm1, %%xmm2\n\t"
++- " jmp .%=L1_test\n\t"
++- " # 4 taps / loop\n\t"
++- " # something like ?? cycles / loop\n\t"
++- ".%=Loop1: \n\t"
++- "# complex prod: C += A * B, w/ temp Z & Y (or B), xmmPN=$0x8000000080000000\n\t"
++- "# movaps (%[eax]), %%xmmA\n\t"
++- "# movaps (%[edx]), %%xmmB\n\t"
++- "# movaps %%xmmA, %%xmmZ\n\t"
++- "# shufps $0xb1, %%xmmZ, %%xmmZ # swap internals\n\t"
++- "# mulps %%xmmB, %%xmmA\n\t"
++- "# mulps %%xmmZ, %%xmmB\n\t"
++- "# # SSE replacement for: pfpnacc %%xmmB, %%xmmA\n\t"
++- "# xorps %%xmmPN, %%xmmA\n\t"
++- "# movaps %%xmmA, %%xmmZ\n\t"
++- "# unpcklps %%xmmB, %%xmmA\n\t"
++- "# unpckhps %%xmmB, %%xmmZ\n\t"
++- "# movaps %%xmmZ, %%xmmY\n\t"
++- "# shufps $0x44, %%xmmA, %%xmmZ # b01000100\n\t"
++- "# shufps $0xee, %%xmmY, %%xmmA # b11101110\n\t"
++- "# addps %%xmmZ, %%xmmA\n\t"
++- "# addps %%xmmA, %%xmmC\n\t"
++- "# A=xmm0, B=xmm2, Z=xmm4\n\t"
++- "# A'=xmm1, B'=xmm3, Z'=xmm5\n\t"
++- " movaps 16(%[edx]), %%xmm3\n\t"
++- " movaps %%xmm0, %%xmm4\n\t"
++- " xorps %%xmm1, %%xmm3\n\t"
++- " mulps %%xmm2, %%xmm0\n\t"
++- " movaps 16(%[eax]), %%xmm1\n\t"
++- " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
++- " movaps %%xmm1, %%xmm5\n\t"
++- " addps %%xmm0, %%xmm6\n\t"
++- " mulps %%xmm3, %%xmm1\n\t"
++- " shufps $0xb1, %%xmm5, %%xmm5 # swap internals\n\t"
++- " addps %%xmm1, %%xmm6\n\t"
++- " movaps 0(%[conjugator]), %%xmm1\n\t"
++- " mulps %%xmm4, %%xmm2\n\t"
++- " movaps 32(%[eax]), %%xmm0\n\t"
++- " addps %%xmm2, %%xmm7\n\t"
++- " mulps %%xmm5, %%xmm3\n\t"
++- " addl $32, %[eax]\n\t"
++- " movaps 32(%[edx]), %%xmm2\n\t"
++- " addps %%xmm3, %%xmm7\n\t"
++- " xorps %%xmm1, %%xmm2\n\t"
++- " addl $32, %[edx]\n\t"
++- ".%=L1_test:\n\t"
++- " decl %[ecx]\n\t"
++- " jge .%=Loop1\n\t"
++- " # We've handled the bulk of multiplies up to here.\n\t"
++- " # Let's sse if original n_2_ccomplex_blocks was odd.\n\t"
++- " # If so, we've got 2 more taps to do.\n\t"
++- " movl 0(%[out]), %[ecx] # n_2_ccomplex_blocks\n\t"
++- " shrl $4, %[ecx]\n\t"
++- " andl $1, %[ecx]\n\t"
++- " je .%=Leven\n\t"
++- " # The count was odd, do 2 more taps.\n\t"
++- " # Note that we've already got mm0/mm2 preloaded\n\t"
++- " # from the main loop.\n\t"
++- " movaps %%xmm0, %%xmm4\n\t"
++- " mulps %%xmm2, %%xmm0\n\t"
++- " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
++- " addps %%xmm0, %%xmm6\n\t"
++- " mulps %%xmm4, %%xmm2\n\t"
++- " addps %%xmm2, %%xmm7\n\t"
++- ".%=Leven:\n\t"
++- " # neg inversor\n\t"
++- " #movl 8(%%ebp), %[eax] \n\t"
++- " xorps %%xmm1, %%xmm1\n\t"
++- " movl $0x80000000, (%[out])\n\t"
++- " movss (%[out]), %%xmm1\n\t"
++- " shufps $0x11, %%xmm1, %%xmm1 # b00010001 # 0 -0 0 -0\n\t"
++- " # pfpnacc\n\t"
++- " xorps %%xmm1, %%xmm6\n\t"
++- " movaps %%xmm6, %%xmm2\n\t"
++- " unpcklps %%xmm7, %%xmm6\n\t"
++- " unpckhps %%xmm7, %%xmm2\n\t"
++- " movaps %%xmm2, %%xmm3\n\t"
++- " shufps $0x44, %%xmm6, %%xmm2 # b01000100\n\t"
++- " shufps $0xee, %%xmm3, %%xmm6 # b11101110\n\t"
++- " addps %%xmm2, %%xmm6\n\t"
++- " # xmm6 = r1 i2 r3 i4\n\t"
++- " #movl 8(%%ebp), %[eax] # @result\n\t"
++- " movhlps %%xmm6, %%xmm4 # xmm4 = r3 i4 ?? ??\n\t"
++- " addps %%xmm4, %%xmm6 # xmm6 = r1+r3 i2+i4 ?? ??\n\t"
++- " movlps %%xmm6, (%[out]) # store low 2x32 bits (complex) to memory\n\t"
++- " #popl %%ebp\n\t"
++- :
++- : [eax] "r" (input), [edx] "r" (taps), [ecx] "r" (num_bytes), [out] "r" (result), [conjugator] "r" (conjugator)
++- );
++-
++- for(; leftovers > 0; leftovers -= 8) {
++- *result += (input[(bound << 1)] * lv_conj(taps[(bound << 1)]));
++- }
+++static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_sse_32(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
+++
+++ const unsigned int num_bytes = num_points * 8;
+++
+++ __VOLK_ATTR_ALIGNED(16)
+++ static const uint32_t conjugator[4] = {
+++ 0x00000000, 0x80000000, 0x00000000, 0x80000000
+++ };
+++
+++ int bound = num_bytes >> 4;
+++ int leftovers = num_bytes % 16;
+++
+++ __VOLK_ASM __VOLK_VOLATILE(
+++ " #pushl %%ebp\n\t"
+++ " #movl %%esp, %%ebp\n\t"
+++ " #movl 12(%%ebp), %%eax # input\n\t"
+++ " #movl 16(%%ebp), %%edx # taps\n\t"
+++ " #movl 20(%%ebp), %%ecx # n_bytes\n\t"
+++ " movaps 0(%[conjugator]), %%xmm1\n\t"
+++ " xorps %%xmm6, %%xmm6 # zero accumulators\n\t"
+++ " movaps 0(%[eax]), %%xmm0\n\t"
+++ " xorps %%xmm7, %%xmm7 # zero accumulators\n\t"
+++ " movaps 0(%[edx]), %%xmm2\n\t"
+++ " movl %[ecx], (%[out])\n\t"
+++ " shrl $5, %[ecx] # ecx = n_2_ccomplex_blocks / 2\n\t"
+++
+++ " xorps %%xmm1, %%xmm2\n\t"
+++ " jmp .%=L1_test\n\t"
+++ " # 4 taps / loop\n\t"
+++ " # something like ?? cycles / loop\n\t"
+++ ".%=Loop1: \n\t"
+++ "# complex prod: C += A * B, w/ temp Z & Y (or B), xmmPN=$0x8000000080000000\n\t"
+++ "# movaps (%[eax]), %%xmmA\n\t"
+++ "# movaps (%[edx]), %%xmmB\n\t"
+++ "# movaps %%xmmA, %%xmmZ\n\t"
+++ "# shufps $0xb1, %%xmmZ, %%xmmZ # swap internals\n\t"
+++ "# mulps %%xmmB, %%xmmA\n\t"
+++ "# mulps %%xmmZ, %%xmmB\n\t"
+++ "# # SSE replacement for: pfpnacc %%xmmB, %%xmmA\n\t"
+++ "# xorps %%xmmPN, %%xmmA\n\t"
+++ "# movaps %%xmmA, %%xmmZ\n\t"
+++ "# unpcklps %%xmmB, %%xmmA\n\t"
+++ "# unpckhps %%xmmB, %%xmmZ\n\t"
+++ "# movaps %%xmmZ, %%xmmY\n\t"
+++ "# shufps $0x44, %%xmmA, %%xmmZ # b01000100\n\t"
+++ "# shufps $0xee, %%xmmY, %%xmmA # b11101110\n\t"
+++ "# addps %%xmmZ, %%xmmA\n\t"
+++ "# addps %%xmmA, %%xmmC\n\t"
+++ "# A=xmm0, B=xmm2, Z=xmm4\n\t"
+++ "# A'=xmm1, B'=xmm3, Z'=xmm5\n\t"
+++ " movaps 16(%[edx]), %%xmm3\n\t"
+++ " movaps %%xmm0, %%xmm4\n\t"
+++ " xorps %%xmm1, %%xmm3\n\t"
+++ " mulps %%xmm2, %%xmm0\n\t"
+++ " movaps 16(%[eax]), %%xmm1\n\t"
+++ " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
+++ " movaps %%xmm1, %%xmm5\n\t"
+++ " addps %%xmm0, %%xmm6\n\t"
+++ " mulps %%xmm3, %%xmm1\n\t"
+++ " shufps $0xb1, %%xmm5, %%xmm5 # swap internals\n\t"
+++ " addps %%xmm1, %%xmm6\n\t"
+++ " movaps 0(%[conjugator]), %%xmm1\n\t"
+++ " mulps %%xmm4, %%xmm2\n\t"
+++ " movaps 32(%[eax]), %%xmm0\n\t"
+++ " addps %%xmm2, %%xmm7\n\t"
+++ " mulps %%xmm5, %%xmm3\n\t"
+++ " addl $32, %[eax]\n\t"
+++ " movaps 32(%[edx]), %%xmm2\n\t"
+++ " addps %%xmm3, %%xmm7\n\t"
+++ " xorps %%xmm1, %%xmm2\n\t"
+++ " addl $32, %[edx]\n\t"
+++ ".%=L1_test:\n\t"
+++ " decl %[ecx]\n\t"
+++ " jge .%=Loop1\n\t"
+++ " # We've handled the bulk of multiplies up to here.\n\t"
+++ " # Let's sse if original n_2_ccomplex_blocks was odd.\n\t"
+++ " # If so, we've got 2 more taps to do.\n\t"
+++ " movl 0(%[out]), %[ecx] # n_2_ccomplex_blocks\n\t"
+++ " shrl $4, %[ecx]\n\t"
+++ " andl $1, %[ecx]\n\t"
+++ " je .%=Leven\n\t"
+++ " # The count was odd, do 2 more taps.\n\t"
+++ " # Note that we've already got mm0/mm2 preloaded\n\t"
+++ " # from the main loop.\n\t"
+++ " movaps %%xmm0, %%xmm4\n\t"
+++ " mulps %%xmm2, %%xmm0\n\t"
+++ " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
+++ " addps %%xmm0, %%xmm6\n\t"
+++ " mulps %%xmm4, %%xmm2\n\t"
+++ " addps %%xmm2, %%xmm7\n\t"
+++ ".%=Leven:\n\t"
+++ " # neg inversor\n\t"
+++ " #movl 8(%%ebp), %[eax] \n\t"
+++ " xorps %%xmm1, %%xmm1\n\t"
+++ " movl $0x80000000, (%[out])\n\t"
+++ " movss (%[out]), %%xmm1\n\t"
+++ " shufps $0x11, %%xmm1, %%xmm1 # b00010001 # 0 -0 0 -0\n\t"
+++ " # pfpnacc\n\t"
+++ " xorps %%xmm1, %%xmm6\n\t"
+++ " movaps %%xmm6, %%xmm2\n\t"
+++ " unpcklps %%xmm7, %%xmm6\n\t"
+++ " unpckhps %%xmm7, %%xmm2\n\t"
+++ " movaps %%xmm2, %%xmm3\n\t"
+++ " shufps $0x44, %%xmm6, %%xmm2 # b01000100\n\t"
+++ " shufps $0xee, %%xmm3, %%xmm6 # b11101110\n\t"
+++ " addps %%xmm2, %%xmm6\n\t"
+++ " # xmm6 = r1 i2 r3 i4\n\t"
+++ " #movl 8(%%ebp), %[eax] # @result\n\t"
+++ " movhlps %%xmm6, %%xmm4 # xmm4 = r3 i4 ?? ??\n\t"
+++ " addps %%xmm4, %%xmm6 # xmm6 = r1+r3 i2+i4 ?? ??\n\t"
+++ " movlps %%xmm6, (%[out]) # store low 2x32 bits (complex) "
+++ "to memory\n\t"
+++ " #popl %%ebp\n\t"
+++ :
+++ : [eax] "r"(input),
+++ [edx] "r"(taps),
+++ [ecx] "r"(num_bytes),
+++ [out] "r"(result),
+++ [conjugator] "r"(conjugator));
+++
+++ for (; leftovers > 0; leftovers -= 8) {
+++ *result += (input[(bound << 1)] * lv_conj(taps[(bound << 1)]));
+++ }
++ }
++ #endif /*LV_HAVE_SSE*/
++
++diff --git a/kernels/volk/volk_32fc_x2_divide_32fc.h b/kernels/volk/volk_32fc_x2_divide_32fc.h
++index 3ce6ede..78c245a 100644
++--- a/kernels/volk/volk_32fc_x2_divide_32fc.h
+++++ b/kernels/volk/volk_32fc_x2_divide_32fc.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_x2_divide_32fc(lv_32fc_t* cVector, const lv_32fc_t* numeratorVector, const lv_32fc_t* denumeratorVector, unsigned int num_points);
++- * \endcode
+++ * void volk_32fc_x2_divide_32fc(lv_32fc_t* cVector, const lv_32fc_t* numeratorVector,
+++ * const lv_32fc_t* denumeratorVector, unsigned int num_points); \endcode
++ *
++ * \b Inputs
++ * \li numeratorVector: The numerator complex values.
++@@ -41,7 +41,8 @@
++ * \li outputVector: The output vector complex floats.
++ *
++ * \b Example
++- * divide a complex vector by itself, demonstrating the result should be pretty close to 1+0j.
+++ * divide a complex vector by itself, demonstrating the result should be pretty close to
+++ * 1+0j.
++ *
++ * \code
++ * int N = 10;
++@@ -71,17 +72,18 @@
++ #ifndef INCLUDED_volk_32fc_x2_divide_32fc_u_H
++ #define INCLUDED_volk_32fc_x2_divide_32fc_u_H
++
+++#include <float.h>
++ #include <inttypes.h>
++ #include <volk/volk_complex.h>
++-#include <float.h>
++
++ #ifdef LV_HAVE_SSE3
++ #include <pmmintrin.h>
++ #include <volk/volk_sse3_intrinsics.h>
++
++-static inline void
++-volk_32fc_x2_divide_32fc_u_sse3(lv_32fc_t* cVector, const lv_32fc_t* numeratorVector,
++- const lv_32fc_t* denumeratorVector, unsigned int num_points)
+++static inline void volk_32fc_x2_divide_32fc_u_sse3(lv_32fc_t* cVector,
+++ const lv_32fc_t* numeratorVector,
+++ const lv_32fc_t* denumeratorVector,
+++ unsigned int num_points)
++ {
++ /*
++ * we'll do the "classical"
++@@ -89,44 +91,46 @@ volk_32fc_x2_divide_32fc_u_sse3(lv_32fc_t* cVector, const lv_32fc_t* numeratorVe
++ * --- = -------
++ * b |b|^2
++ * */
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- __m128 num01, num23, den01, den23, norm, result;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = numeratorVector;
++- const lv_32fc_t* b = denumeratorVector;
++-
++- for(; number < quarterPoints; number++){
++- num01 = _mm_loadu_ps((float*) a); // first pair
++- den01 = _mm_loadu_ps((float*) b); // first pair
++- num01 = _mm_complexconjugatemul_ps(num01, den01); // a conj(b)
++- a += 2;
++- b += 2;
++-
++- num23 = _mm_loadu_ps((float*) a); // second pair
++- den23 = _mm_loadu_ps((float*) b); // second pair
++- num23 = _mm_complexconjugatemul_ps(num23, den23); // a conj(b)
++- a += 2;
++- b += 2;
++-
++- norm = _mm_magnitudesquared_ps_sse3(den01, den23);
++- den01 = _mm_unpacklo_ps(norm,norm);
++- den23 = _mm_unpackhi_ps(norm,norm);
++-
++- result = _mm_div_ps(num01, den01);
++- _mm_storeu_ps((float*) c, result); // Store the results back into the C container
++- c += 2;
++- result = _mm_div_ps(num23, den23);
++- _mm_storeu_ps((float*) c, result); // Store the results back into the C container
++- c += 2;
++- }
++-
++- number *= 4;
++- for(;number < num_points; number++){
++- *c = (*a) / (*b);
++- a++; b++; c++;
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ __m128 num01, num23, den01, den23, norm, result;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = numeratorVector;
+++ const lv_32fc_t* b = denumeratorVector;
+++
+++ for (; number < quarterPoints; number++) {
+++ num01 = _mm_loadu_ps((float*)a); // first pair
+++ den01 = _mm_loadu_ps((float*)b); // first pair
+++ num01 = _mm_complexconjugatemul_ps(num01, den01); // a conj(b)
+++ a += 2;
+++ b += 2;
+++
+++ num23 = _mm_loadu_ps((float*)a); // second pair
+++ den23 = _mm_loadu_ps((float*)b); // second pair
+++ num23 = _mm_complexconjugatemul_ps(num23, den23); // a conj(b)
+++ a += 2;
+++ b += 2;
+++
+++ norm = _mm_magnitudesquared_ps_sse3(den01, den23);
+++ den01 = _mm_unpacklo_ps(norm, norm);
+++ den23 = _mm_unpackhi_ps(norm, norm);
+++
+++ result = _mm_div_ps(num01, den01);
+++ _mm_storeu_ps((float*)c, result); // Store the results back into the C container
+++ c += 2;
+++ result = _mm_div_ps(num23, den23);
+++ _mm_storeu_ps((float*)c, result); // Store the results back into the C container
+++ c += 2;
+++ }
+++
+++ number *= 4;
+++ for (; number < num_points; number++) {
+++ *c = (*a) / (*b);
+++ a++;
+++ b++;
+++ c++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE3 */
++
++@@ -135,9 +139,10 @@ volk_32fc_x2_divide_32fc_u_sse3(lv_32fc_t* cVector, const lv_32fc_t* numeratorVe
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void
++-volk_32fc_x2_divide_32fc_u_avx(lv_32fc_t* cVector, const lv_32fc_t* numeratorVector,
++- const lv_32fc_t* denumeratorVector, unsigned int num_points)
+++static inline void volk_32fc_x2_divide_32fc_u_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* numeratorVector,
+++ const lv_32fc_t* denumeratorVector,
+++ unsigned int num_points)
++ {
++ /*
++ * we'll do the "classical"
++@@ -153,17 +158,21 @@ volk_32fc_x2_divide_32fc_u_avx(lv_32fc_t* cVector, const lv_32fc_t* numeratorVec
++ const lv_32fc_t* a = numeratorVector;
++ const lv_32fc_t* b = denumeratorVector;
++
++- for(; number < quarterPoints; number++){
++- num = _mm256_loadu_ps((float*) a); // Load the ar + ai, br + bi ... as ar,ai,br,bi ...
++- denum = _mm256_loadu_ps((float*) b); // Load the cr + ci, dr + di ... as cr,ci,dr,di ...
+++ for (; number < quarterPoints; number++) {
+++ num = _mm256_loadu_ps(
+++ (float*)a); // Load the ar + ai, br + bi ... as ar,ai,br,bi ...
+++ denum = _mm256_loadu_ps(
+++ (float*)b); // Load the cr + ci, dr + di ... as cr,ci,dr,di ...
++ mul_conj = _mm256_complexconjugatemul_ps(num, denum);
++ sq = _mm256_mul_ps(denum, denum); // Square the values
++- mag_sq_un = _mm256_hadd_ps(sq,sq); // obtain the actual squared magnitude, although out of order
+++ mag_sq_un = _mm256_hadd_ps(
+++ sq, sq); // obtain the actual squared magnitude, although out of order
++ mag_sq = _mm256_permute_ps(mag_sq_un, 0xd8); // I order them
++- // best guide I found on using these functions: https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=2738,2059,2738,2738,3875,3874,3875,2738,3870
++- div = _mm256_div_ps(mul_conj,mag_sq);
+++ // best guide I found on using these functions:
+++ // https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=2738,2059,2738,2738,3875,3874,3875,2738,3870
+++ div = _mm256_div_ps(mul_conj, mag_sq);
++
++- _mm256_storeu_ps((float*) c, div); // Store the results back into the C container
+++ _mm256_storeu_ps((float*)c, div); // Store the results back into the C container
++
++ a += 4;
++ b += 4;
++@@ -172,51 +181,51 @@ volk_32fc_x2_divide_32fc_u_avx(lv_32fc_t* cVector, const lv_32fc_t* numeratorVec
++
++ number = quarterPoints * 4;
++
++- for(; number < num_points; number++){
+++ for (; number < num_points; number++) {
++ *c++ = (*a++) / (*b++);
++ }
++-
++ }
++ #endif /* LV_HAVE_AVX */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_x2_divide_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_divide_32fc_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const lv_32fc_t* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) / (*bPtr++);
++- }
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const lv_32fc_t* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) / (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++ #endif /* INCLUDED_volk_32fc_x2_divide_32fc_u_H */
++
++
++ #ifndef INCLUDED_volk_32fc_x2_divide_32fc_a_H
++ #define INCLUDED_volk_32fc_x2_divide_32fc_a_H
++
+++#include <float.h>
++ #include <inttypes.h>
++ #include <stdio.h>
++ #include <volk/volk_complex.h>
++-#include <float.h>
++
++ #ifdef LV_HAVE_SSE3
++ #include <pmmintrin.h>
++ #include <volk/volk_sse3_intrinsics.h>
++
++-static inline void
++-volk_32fc_x2_divide_32fc_a_sse3(lv_32fc_t* cVector, const lv_32fc_t* numeratorVector,
++- const lv_32fc_t* denumeratorVector, unsigned int num_points)
+++static inline void volk_32fc_x2_divide_32fc_a_sse3(lv_32fc_t* cVector,
+++ const lv_32fc_t* numeratorVector,
+++ const lv_32fc_t* denumeratorVector,
+++ unsigned int num_points)
++ {
++ /*
++ * we'll do the "classical"
++@@ -224,45 +233,47 @@ volk_32fc_x2_divide_32fc_a_sse3(lv_32fc_t* cVector, const lv_32fc_t* numeratorVe
++ * --- = -------
++ * b |b|^2
++ * */
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- __m128 num01, num23, den01, den23, norm, result;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = numeratorVector;
++- const lv_32fc_t* b = denumeratorVector;
++-
++- for(; number < quarterPoints; number++){
++- num01 = _mm_load_ps((float*) a); // first pair
++- den01 = _mm_load_ps((float*) b); // first pair
++- num01 = _mm_complexconjugatemul_ps(num01, den01); // a conj(b)
++- a += 2;
++- b += 2;
++-
++- num23 = _mm_load_ps((float*) a); // second pair
++- den23 = _mm_load_ps((float*) b); // second pair
++- num23 = _mm_complexconjugatemul_ps(num23, den23); // a conj(b)
++- a += 2;
++- b += 2;
++-
++- norm = _mm_magnitudesquared_ps_sse3(den01, den23);
++-
++- den01 = _mm_unpacklo_ps(norm,norm); // select the lower floats twice
++- den23 = _mm_unpackhi_ps(norm,norm); // select the upper floats twice
++-
++- result = _mm_div_ps(num01, den01);
++- _mm_store_ps((float*) c, result); // Store the results back into the C container
++- c += 2;
++- result = _mm_div_ps(num23, den23);
++- _mm_store_ps((float*) c, result); // Store the results back into the C container
++- c += 2;
++- }
++-
++- number *= 4;
++- for(;number < num_points; number++){
++- *c = (*a) / (*b);
++- a++; b++; c++;
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ __m128 num01, num23, den01, den23, norm, result;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = numeratorVector;
+++ const lv_32fc_t* b = denumeratorVector;
+++
+++ for (; number < quarterPoints; number++) {
+++ num01 = _mm_load_ps((float*)a); // first pair
+++ den01 = _mm_load_ps((float*)b); // first pair
+++ num01 = _mm_complexconjugatemul_ps(num01, den01); // a conj(b)
+++ a += 2;
+++ b += 2;
+++
+++ num23 = _mm_load_ps((float*)a); // second pair
+++ den23 = _mm_load_ps((float*)b); // second pair
+++ num23 = _mm_complexconjugatemul_ps(num23, den23); // a conj(b)
+++ a += 2;
+++ b += 2;
+++
+++ norm = _mm_magnitudesquared_ps_sse3(den01, den23);
+++
+++ den01 = _mm_unpacklo_ps(norm, norm); // select the lower floats twice
+++ den23 = _mm_unpackhi_ps(norm, norm); // select the upper floats twice
+++
+++ result = _mm_div_ps(num01, den01);
+++ _mm_store_ps((float*)c, result); // Store the results back into the C container
+++ c += 2;
+++ result = _mm_div_ps(num23, den23);
+++ _mm_store_ps((float*)c, result); // Store the results back into the C container
+++ c += 2;
+++ }
+++
+++ number *= 4;
+++ for (; number < num_points; number++) {
+++ *c = (*a) / (*b);
+++ a++;
+++ b++;
+++ c++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -270,9 +281,10 @@ volk_32fc_x2_divide_32fc_a_sse3(lv_32fc_t* cVector, const lv_32fc_t* numeratorVe
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void
++-volk_32fc_x2_divide_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* numeratorVector,
++- const lv_32fc_t* denumeratorVector, unsigned int num_points)
+++static inline void volk_32fc_x2_divide_32fc_a_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* numeratorVector,
+++ const lv_32fc_t* denumeratorVector,
+++ unsigned int num_points)
++ {
++ /*
++ * we'll do the "classical"
++@@ -288,17 +300,21 @@ volk_32fc_x2_divide_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* numeratorVec
++ const lv_32fc_t* a = numeratorVector;
++ const lv_32fc_t* b = denumeratorVector;
++
++- for(; number < quarterPoints; number++){
++- num = _mm256_load_ps((float*) a); // Load the ar + ai, br + bi ... as ar,ai,br,bi ...
++- denum = _mm256_load_ps((float*) b); // Load the cr + ci, dr + di ... as cr,ci,dr,di ...
+++ for (; number < quarterPoints; number++) {
+++ num =
+++ _mm256_load_ps((float*)a); // Load the ar + ai, br + bi ... as ar,ai,br,bi ...
+++ denum =
+++ _mm256_load_ps((float*)b); // Load the cr + ci, dr + di ... as cr,ci,dr,di ...
++ mul_conj = _mm256_complexconjugatemul_ps(num, denum);
++ sq = _mm256_mul_ps(denum, denum); // Square the values
++- mag_sq_un = _mm256_hadd_ps(sq,sq); // obtain the actual squared magnitude, although out of order
+++ mag_sq_un = _mm256_hadd_ps(
+++ sq, sq); // obtain the actual squared magnitude, although out of order
++ mag_sq = _mm256_permute_ps(mag_sq_un, 0xd8); // I order them
++- // best guide I found on using these functions: https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=2738,2059,2738,2738,3875,3874,3875,2738,3870
++- div = _mm256_div_ps(mul_conj,mag_sq);
+++ // best guide I found on using these functions:
+++ // https://software.intel.com/sites/landingpage/IntrinsicsGuide/#expand=2738,2059,2738,2738,3875,3874,3875,2738,3870
+++ div = _mm256_div_ps(mul_conj, mag_sq);
++
++- _mm256_store_ps((float*) c, div); // Store the results back into the C container
+++ _mm256_store_ps((float*)c, div); // Store the results back into the C container
++
++ a += 4;
++ b += 4;
++@@ -307,78 +323,78 @@ volk_32fc_x2_divide_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* numeratorVec
++
++ number = quarterPoints * 4;
++
++- for(; number < num_points; number++){
+++ for (; number < num_points; number++) {
++ *c++ = (*a++) / (*b++);
++ }
++-
++-
++ }
++ #endif /* LV_HAVE_AVX */
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32fc_x2_divide_32fc_neon(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_divide_32fc_neon(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const lv_32fc_t* bPtr = bVector;
++-
++- float32x4x2_t aVal, bVal, cVal;
++- float32x4_t bAbs, bAbsInv;
++-
++- const unsigned int quarterPoints = num_points / 4;
++- unsigned int number = 0;
++- for(; number < quarterPoints; number++){
++- aVal = vld2q_f32((const float*)(aPtr));
++- bVal = vld2q_f32((const float*)(bPtr));
++- aPtr += 4;
++- bPtr += 4;
++- __VOLK_PREFETCH(aPtr+4);
++- __VOLK_PREFETCH(bPtr+4);
++-
++- bAbs = vmulq_f32( bVal.val[0], bVal.val[0]);
++- bAbs = vmlaq_f32(bAbs, bVal.val[1], bVal.val[1]);
++-
++- bAbsInv = vrecpeq_f32(bAbs);
++- bAbsInv = vmulq_f32(bAbsInv, vrecpsq_f32(bAbsInv, bAbs));
++- bAbsInv = vmulq_f32(bAbsInv, vrecpsq_f32(bAbsInv, bAbs));
++-
++- cVal.val[0] = vmulq_f32( aVal.val[0], bVal.val[0]);
++- cVal.val[0] = vmlaq_f32(cVal.val[0], aVal.val[1], bVal.val[1]);
++- cVal.val[0] = vmulq_f32(cVal.val[0], bAbsInv);
++-
++- cVal.val[1] = vmulq_f32( aVal.val[1], bVal.val[0]);
++- cVal.val[1] = vmlsq_f32(cVal.val[1], aVal.val[0], bVal.val[1]);
++- cVal.val[1] = vmulq_f32(cVal.val[1], bAbsInv);
++-
++- vst2q_f32((float*)(cPtr), cVal);
++- cPtr += 4;
++- }
++-
++- for(number = quarterPoints * 4; number < num_points; number++){
++- *cPtr++ = (*aPtr++) / (*bPtr++);
++- }
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const lv_32fc_t* bPtr = bVector;
+++
+++ float32x4x2_t aVal, bVal, cVal;
+++ float32x4_t bAbs, bAbsInv;
+++
+++ const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ for (; number < quarterPoints; number++) {
+++ aVal = vld2q_f32((const float*)(aPtr));
+++ bVal = vld2q_f32((const float*)(bPtr));
+++ aPtr += 4;
+++ bPtr += 4;
+++ __VOLK_PREFETCH(aPtr + 4);
+++ __VOLK_PREFETCH(bPtr + 4);
+++
+++ bAbs = vmulq_f32(bVal.val[0], bVal.val[0]);
+++ bAbs = vmlaq_f32(bAbs, bVal.val[1], bVal.val[1]);
+++
+++ bAbsInv = vrecpeq_f32(bAbs);
+++ bAbsInv = vmulq_f32(bAbsInv, vrecpsq_f32(bAbsInv, bAbs));
+++ bAbsInv = vmulq_f32(bAbsInv, vrecpsq_f32(bAbsInv, bAbs));
+++
+++ cVal.val[0] = vmulq_f32(aVal.val[0], bVal.val[0]);
+++ cVal.val[0] = vmlaq_f32(cVal.val[0], aVal.val[1], bVal.val[1]);
+++ cVal.val[0] = vmulq_f32(cVal.val[0], bAbsInv);
+++
+++ cVal.val[1] = vmulq_f32(aVal.val[1], bVal.val[0]);
+++ cVal.val[1] = vmlsq_f32(cVal.val[1], aVal.val[0], bVal.val[1]);
+++ cVal.val[1] = vmulq_f32(cVal.val[1], bAbsInv);
+++
+++ vst2q_f32((float*)(cPtr), cVal);
+++ cPtr += 4;
+++ }
+++
+++ for (number = quarterPoints * 4; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) / (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_x2_divide_32fc_a_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_divide_32fc_a_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const lv_32fc_t* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) / (*bPtr++);
++- }
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const lv_32fc_t* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) / (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32fc_x2_dot_prod_32fc.h b/kernels/volk/volk_32fc_x2_dot_prod_32fc.h
++index f4a4469..b0b7fee 100644
++--- a/kernels/volk/volk_32fc_x2_dot_prod_32fc.h
+++++ b/kernels/volk/volk_32fc_x2_dot_prod_32fc.h
++@@ -33,8 +33,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_x2_dot_prod_32fc(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_x2_dot_prod_32fc(lv_32fc_t* result, const lv_32fc_t* input, const
+++ * lv_32fc_t* taps, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li input: vector of complex floats.
++@@ -58,236 +58,246 @@
++ #ifndef INCLUDED_volk_32fc_x2_dot_prod_32fc_u_H
++ #define INCLUDED_volk_32fc_x2_dot_prod_32fc_u_H
++
++-#include <volk/volk_common.h>
++-#include <volk/volk_complex.h>
++ #include <stdio.h>
++ #include <string.h>
+++#include <volk/volk_common.h>
+++#include <volk/volk_complex.h>
++
++
++ #ifdef LV_HAVE_GENERIC
++
++
++-static inline void volk_32fc_x2_dot_prod_32fc_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_generic(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- float * res = (float*) result;
++- float * in = (float*) input;
++- float * tp = (float*) taps;
++- unsigned int n_2_ccomplex_blocks = num_points/2;
+++ float* res = (float*)result;
+++ float* in = (float*)input;
+++ float* tp = (float*)taps;
+++ unsigned int n_2_ccomplex_blocks = num_points / 2;
++
++- float sum0[2] = {0,0};
++- float sum1[2] = {0,0};
++- unsigned int i = 0;
+++ float sum0[2] = { 0, 0 };
+++ float sum1[2] = { 0, 0 };
+++ unsigned int i = 0;
++
++- for(i = 0; i < n_2_ccomplex_blocks; ++i) {
++- sum0[0] += in[0] * tp[0] - in[1] * tp[1];
++- sum0[1] += in[0] * tp[1] + in[1] * tp[0];
++- sum1[0] += in[2] * tp[2] - in[3] * tp[3];
++- sum1[1] += in[2] * tp[3] + in[3] * tp[2];
+++ for (i = 0; i < n_2_ccomplex_blocks; ++i) {
+++ sum0[0] += in[0] * tp[0] - in[1] * tp[1];
+++ sum0[1] += in[0] * tp[1] + in[1] * tp[0];
+++ sum1[0] += in[2] * tp[2] - in[3] * tp[3];
+++ sum1[1] += in[2] * tp[3] + in[3] * tp[2];
++
++- in += 4;
++- tp += 4;
++- }
+++ in += 4;
+++ tp += 4;
+++ }
++
++- res[0] = sum0[0] + sum1[0];
++- res[1] = sum0[1] + sum1[1];
+++ res[0] = sum0[0] + sum1[0];
+++ res[1] = sum0[1] + sum1[1];
++
++- // Cleanup if we had an odd number of points
++- if (num_points & 1) {
++- *result += input[num_points - 1] * taps[num_points - 1];
++- }
+++ // Cleanup if we had an odd number of points
+++ if (num_points & 1) {
+++ *result += input[num_points - 1] * taps[num_points - 1];
+++ }
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++
++
++-
++ #if LV_HAVE_SSE && LV_HAVE_64
++
++-static inline void volk_32fc_x2_dot_prod_32fc_u_sse_64(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
++-
++- const unsigned int num_bytes = num_points*8;
++- unsigned int isodd = num_points & 1;
++-
++- __VOLK_ASM
++- (
++- "# ccomplex_dotprod_generic (float* result, const float *input,\n\t"
++- "# const float *taps, unsigned num_bytes)\n\t"
++- "# float sum0 = 0;\n\t"
++- "# float sum1 = 0;\n\t"
++- "# float sum2 = 0;\n\t"
++- "# float sum3 = 0;\n\t"
++- "# do {\n\t"
++- "# sum0 += input[0] * taps[0] - input[1] * taps[1];\n\t"
++- "# sum1 += input[0] * taps[1] + input[1] * taps[0];\n\t"
++- "# sum2 += input[2] * taps[2] - input[3] * taps[3];\n\t"
++- "# sum3 += input[2] * taps[3] + input[3] * taps[2];\n\t"
++- "# input += 4;\n\t"
++- "# taps += 4; \n\t"
++- "# } while (--n_2_ccomplex_blocks != 0);\n\t"
++- "# result[0] = sum0 + sum2;\n\t"
++- "# result[1] = sum1 + sum3;\n\t"
++- "# TODO: prefetch and better scheduling\n\t"
++- " xor %%r9, %%r9\n\t"
++- " xor %%r10, %%r10\n\t"
++- " movq %%rcx, %%rax\n\t"
++- " movq %%rcx, %%r8\n\t"
++- " movq %[rsi], %%r9\n\t"
++- " movq %[rdx], %%r10\n\t"
++- " xorps %%xmm6, %%xmm6 # zero accumulators\n\t"
++- " movups 0(%%r9), %%xmm0\n\t"
++- " xorps %%xmm7, %%xmm7 # zero accumulators\n\t"
++- " movups 0(%%r10), %%xmm2\n\t"
++- " shr $5, %%rax # rax = n_2_ccomplex_blocks / 2\n\t"
++- " shr $4, %%r8\n\t"
++- " jmp .%=L1_test\n\t"
++- " # 4 taps / loop\n\t"
++- " # something like ?? cycles / loop\n\t"
++- ".%=Loop1: \n\t"
++- "# complex prod: C += A * B, w/ temp Z & Y (or B), xmmPN=$0x8000000080000000\n\t"
++- "# movups (%%r9), %%xmmA\n\t"
++- "# movups (%%r10), %%xmmB\n\t"
++- "# movups %%xmmA, %%xmmZ\n\t"
++- "# shufps $0xb1, %%xmmZ, %%xmmZ # swap internals\n\t"
++- "# mulps %%xmmB, %%xmmA\n\t"
++- "# mulps %%xmmZ, %%xmmB\n\t"
++- "# # SSE replacement for: pfpnacc %%xmmB, %%xmmA\n\t"
++- "# xorps %%xmmPN, %%xmmA\n\t"
++- "# movups %%xmmA, %%xmmZ\n\t"
++- "# unpcklps %%xmmB, %%xmmA\n\t"
++- "# unpckhps %%xmmB, %%xmmZ\n\t"
++- "# movups %%xmmZ, %%xmmY\n\t"
++- "# shufps $0x44, %%xmmA, %%xmmZ # b01000100\n\t"
++- "# shufps $0xee, %%xmmY, %%xmmA # b11101110\n\t"
++- "# addps %%xmmZ, %%xmmA\n\t"
++- "# addps %%xmmA, %%xmmC\n\t"
++- "# A=xmm0, B=xmm2, Z=xmm4\n\t"
++- "# A'=xmm1, B'=xmm3, Z'=xmm5\n\t"
++- " movups 16(%%r9), %%xmm1\n\t"
++- " movups %%xmm0, %%xmm4\n\t"
++- " mulps %%xmm2, %%xmm0\n\t"
++- " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
++- " movups 16(%%r10), %%xmm3\n\t"
++- " movups %%xmm1, %%xmm5\n\t"
++- " addps %%xmm0, %%xmm6\n\t"
++- " mulps %%xmm3, %%xmm1\n\t"
++- " shufps $0xb1, %%xmm5, %%xmm5 # swap internals\n\t"
++- " addps %%xmm1, %%xmm6\n\t"
++- " mulps %%xmm4, %%xmm2\n\t"
++- " movups 32(%%r9), %%xmm0\n\t"
++- " addps %%xmm2, %%xmm7\n\t"
++- " mulps %%xmm5, %%xmm3\n\t"
++- " add $32, %%r9\n\t"
++- " movups 32(%%r10), %%xmm2\n\t"
++- " addps %%xmm3, %%xmm7\n\t"
++- " add $32, %%r10\n\t"
++- ".%=L1_test:\n\t"
++- " dec %%rax\n\t"
++- " jge .%=Loop1\n\t"
++- " # We've handled the bulk of multiplies up to here.\n\t"
++- " # Let's sse if original n_2_ccomplex_blocks was odd.\n\t"
++- " # If so, we've got 2 more taps to do.\n\t"
++- " and $1, %%r8\n\t"
++- " je .%=Leven\n\t"
++- " # The count was odd, do 2 more taps.\n\t"
++- " # Note that we've already got mm0/mm2 preloaded\n\t"
++- " # from the main loop.\n\t"
++- " movups %%xmm0, %%xmm4\n\t"
++- " mulps %%xmm2, %%xmm0\n\t"
++- " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
++- " addps %%xmm0, %%xmm6\n\t"
++- " mulps %%xmm4, %%xmm2\n\t"
++- " addps %%xmm2, %%xmm7\n\t"
++- ".%=Leven:\n\t"
++- " # neg inversor\n\t"
++- " xorps %%xmm1, %%xmm1\n\t"
++- " mov $0x80000000, %%r9\n\t"
++- " movd %%r9, %%xmm1\n\t"
++- " shufps $0x11, %%xmm1, %%xmm1 # b00010001 # 0 -0 0 -0\n\t"
++- " # pfpnacc\n\t"
++- " xorps %%xmm1, %%xmm6\n\t"
++- " movups %%xmm6, %%xmm2\n\t"
++- " unpcklps %%xmm7, %%xmm6\n\t"
++- " unpckhps %%xmm7, %%xmm2\n\t"
++- " movups %%xmm2, %%xmm3\n\t"
++- " shufps $0x44, %%xmm6, %%xmm2 # b01000100\n\t"
++- " shufps $0xee, %%xmm3, %%xmm6 # b11101110\n\t"
++- " addps %%xmm2, %%xmm6\n\t"
++- " # xmm6 = r1 i2 r3 i4\n\t"
++- " movhlps %%xmm6, %%xmm4 # xmm4 = r3 i4 ?? ??\n\t"
++- " addps %%xmm4, %%xmm6 # xmm6 = r1+r3 i2+i4 ?? ??\n\t"
++- " movlps %%xmm6, (%[rdi]) # store low 2x32 bits (complex) to memory\n\t"
++- :
++- :[rsi] "r" (input), [rdx] "r" (taps), "c" (num_bytes), [rdi] "r" (result)
++- :"rax", "r8", "r9", "r10"
++- );
++-
++-
++- if(isodd) {
++- *result += input[num_points - 1] * taps[num_points - 1];
++- }
++-
++- return;
+++static inline void volk_32fc_x2_dot_prod_32fc_u_sse_64(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
+++
+++ const unsigned int num_bytes = num_points * 8;
+++ unsigned int isodd = num_points & 1;
+++
+++ __VOLK_ASM(
+++ "# ccomplex_dotprod_generic (float* result, const float *input,\n\t"
+++ "# const float *taps, unsigned num_bytes)\n\t"
+++ "# float sum0 = 0;\n\t"
+++ "# float sum1 = 0;\n\t"
+++ "# float sum2 = 0;\n\t"
+++ "# float sum3 = 0;\n\t"
+++ "# do {\n\t"
+++ "# sum0 += input[0] * taps[0] - input[1] * taps[1];\n\t"
+++ "# sum1 += input[0] * taps[1] + input[1] * taps[0];\n\t"
+++ "# sum2 += input[2] * taps[2] - input[3] * taps[3];\n\t"
+++ "# sum3 += input[2] * taps[3] + input[3] * taps[2];\n\t"
+++ "# input += 4;\n\t"
+++ "# taps += 4; \n\t"
+++ "# } while (--n_2_ccomplex_blocks != 0);\n\t"
+++ "# result[0] = sum0 + sum2;\n\t"
+++ "# result[1] = sum1 + sum3;\n\t"
+++ "# TODO: prefetch and better scheduling\n\t"
+++ " xor %%r9, %%r9\n\t"
+++ " xor %%r10, %%r10\n\t"
+++ " movq %%rcx, %%rax\n\t"
+++ " movq %%rcx, %%r8\n\t"
+++ " movq %[rsi], %%r9\n\t"
+++ " movq %[rdx], %%r10\n\t"
+++ " xorps %%xmm6, %%xmm6 # zero accumulators\n\t"
+++ " movups 0(%%r9), %%xmm0\n\t"
+++ " xorps %%xmm7, %%xmm7 # zero accumulators\n\t"
+++ " movups 0(%%r10), %%xmm2\n\t"
+++ " shr $5, %%rax # rax = n_2_ccomplex_blocks / 2\n\t"
+++ " shr $4, %%r8\n\t"
+++ " jmp .%=L1_test\n\t"
+++ " # 4 taps / loop\n\t"
+++ " # something like ?? cycles / loop\n\t"
+++ ".%=Loop1: \n\t"
+++ "# complex prod: C += A * B, w/ temp Z & Y (or B), xmmPN=$0x8000000080000000\n\t"
+++ "# movups (%%r9), %%xmmA\n\t"
+++ "# movups (%%r10), %%xmmB\n\t"
+++ "# movups %%xmmA, %%xmmZ\n\t"
+++ "# shufps $0xb1, %%xmmZ, %%xmmZ # swap internals\n\t"
+++ "# mulps %%xmmB, %%xmmA\n\t"
+++ "# mulps %%xmmZ, %%xmmB\n\t"
+++ "# # SSE replacement for: pfpnacc %%xmmB, %%xmmA\n\t"
+++ "# xorps %%xmmPN, %%xmmA\n\t"
+++ "# movups %%xmmA, %%xmmZ\n\t"
+++ "# unpcklps %%xmmB, %%xmmA\n\t"
+++ "# unpckhps %%xmmB, %%xmmZ\n\t"
+++ "# movups %%xmmZ, %%xmmY\n\t"
+++ "# shufps $0x44, %%xmmA, %%xmmZ # b01000100\n\t"
+++ "# shufps $0xee, %%xmmY, %%xmmA # b11101110\n\t"
+++ "# addps %%xmmZ, %%xmmA\n\t"
+++ "# addps %%xmmA, %%xmmC\n\t"
+++ "# A=xmm0, B=xmm2, Z=xmm4\n\t"
+++ "# A'=xmm1, B'=xmm3, Z'=xmm5\n\t"
+++ " movups 16(%%r9), %%xmm1\n\t"
+++ " movups %%xmm0, %%xmm4\n\t"
+++ " mulps %%xmm2, %%xmm0\n\t"
+++ " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
+++ " movups 16(%%r10), %%xmm3\n\t"
+++ " movups %%xmm1, %%xmm5\n\t"
+++ " addps %%xmm0, %%xmm6\n\t"
+++ " mulps %%xmm3, %%xmm1\n\t"
+++ " shufps $0xb1, %%xmm5, %%xmm5 # swap internals\n\t"
+++ " addps %%xmm1, %%xmm6\n\t"
+++ " mulps %%xmm4, %%xmm2\n\t"
+++ " movups 32(%%r9), %%xmm0\n\t"
+++ " addps %%xmm2, %%xmm7\n\t"
+++ " mulps %%xmm5, %%xmm3\n\t"
+++ " add $32, %%r9\n\t"
+++ " movups 32(%%r10), %%xmm2\n\t"
+++ " addps %%xmm3, %%xmm7\n\t"
+++ " add $32, %%r10\n\t"
+++ ".%=L1_test:\n\t"
+++ " dec %%rax\n\t"
+++ " jge .%=Loop1\n\t"
+++ " # We've handled the bulk of multiplies up to here.\n\t"
+++ " # Let's sse if original n_2_ccomplex_blocks was odd.\n\t"
+++ " # If so, we've got 2 more taps to do.\n\t"
+++ " and $1, %%r8\n\t"
+++ " je .%=Leven\n\t"
+++ " # The count was odd, do 2 more taps.\n\t"
+++ " # Note that we've already got mm0/mm2 preloaded\n\t"
+++ " # from the main loop.\n\t"
+++ " movups %%xmm0, %%xmm4\n\t"
+++ " mulps %%xmm2, %%xmm0\n\t"
+++ " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
+++ " addps %%xmm0, %%xmm6\n\t"
+++ " mulps %%xmm4, %%xmm2\n\t"
+++ " addps %%xmm2, %%xmm7\n\t"
+++ ".%=Leven:\n\t"
+++ " # neg inversor\n\t"
+++ " xorps %%xmm1, %%xmm1\n\t"
+++ " mov $0x80000000, %%r9\n\t"
+++ " movd %%r9, %%xmm1\n\t"
+++ " shufps $0x11, %%xmm1, %%xmm1 # b00010001 # 0 -0 0 -0\n\t"
+++ " # pfpnacc\n\t"
+++ " xorps %%xmm1, %%xmm6\n\t"
+++ " movups %%xmm6, %%xmm2\n\t"
+++ " unpcklps %%xmm7, %%xmm6\n\t"
+++ " unpckhps %%xmm7, %%xmm2\n\t"
+++ " movups %%xmm2, %%xmm3\n\t"
+++ " shufps $0x44, %%xmm6, %%xmm2 # b01000100\n\t"
+++ " shufps $0xee, %%xmm3, %%xmm6 # b11101110\n\t"
+++ " addps %%xmm2, %%xmm6\n\t"
+++ " # xmm6 = r1 i2 r3 i4\n\t"
+++ " movhlps %%xmm6, %%xmm4 # xmm4 = r3 i4 ?? ??\n\t"
+++ " addps %%xmm4, %%xmm6 # xmm6 = r1+r3 i2+i4 ?? ??\n\t"
+++ " movlps %%xmm6, (%[rdi]) # store low 2x32 bits (complex) "
+++ "to memory\n\t"
+++ :
+++ : [rsi] "r"(input), [rdx] "r"(taps), "c"(num_bytes), [rdi] "r"(result)
+++ : "rax", "r8", "r9", "r10");
+++
+++
+++ if (isodd) {
+++ *result += input[num_points - 1] * taps[num_points - 1];
+++ }
++
+++ return;
++ }
++
++ #endif /* LV_HAVE_SSE && LV_HAVE_64 */
++
++
++-
++-
++ #ifdef LV_HAVE_SSE3
++
++ #include <pmmintrin.h>
++
++-static inline void volk_32fc_x2_dot_prod_32fc_u_sse3(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_u_sse3(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- lv_32fc_t dotProduct;
++- memset(&dotProduct, 0x0, 2*sizeof(float));
+++ lv_32fc_t dotProduct;
+++ memset(&dotProduct, 0x0, 2 * sizeof(float));
++
++- unsigned int number = 0;
++- const unsigned int halfPoints = num_points/2;
++- unsigned int isodd = num_points & 1;
+++ unsigned int number = 0;
+++ const unsigned int halfPoints = num_points / 2;
+++ unsigned int isodd = num_points & 1;
++
++- __m128 x, y, yl, yh, z, tmp1, tmp2, dotProdVal;
+++ __m128 x, y, yl, yh, z, tmp1, tmp2, dotProdVal;
++
++- const lv_32fc_t* a = input;
++- const lv_32fc_t* b = taps;
+++ const lv_32fc_t* a = input;
+++ const lv_32fc_t* b = taps;
++
++- dotProdVal = _mm_setzero_ps();
+++ dotProdVal = _mm_setzero_ps();
++
++- for(;number < halfPoints; number++){
+++ for (; number < halfPoints; number++) {
++
++- x = _mm_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
++- y = _mm_loadu_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di
+++ x = _mm_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ y = _mm_loadu_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di
++
++- yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr
++- yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di
+++ yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr
+++ yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di
++
++- tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+++ tmp1 = _mm_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
++
++- x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br
+++ x = _mm_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br
++
++- tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+++ tmp2 = _mm_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
++
++- z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ z = _mm_addsub_ps(tmp1,
+++ tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- dotProdVal = _mm_add_ps(dotProdVal, z); // Add the complex multiplication results together
+++ dotProdVal =
+++ _mm_add_ps(dotProdVal, z); // Add the complex multiplication results together
++
++- a += 2;
++- b += 2;
++- }
+++ a += 2;
+++ b += 2;
+++ }
++
++- __VOLK_ATTR_ALIGNED(16) lv_32fc_t dotProductVector[2];
+++ __VOLK_ATTR_ALIGNED(16) lv_32fc_t dotProductVector[2];
++
++- _mm_storeu_ps((float*)dotProductVector,dotProdVal); // Store the results back into the dot product vector
+++ _mm_storeu_ps((float*)dotProductVector,
+++ dotProdVal); // Store the results back into the dot product vector
++
++- dotProduct += ( dotProductVector[0] + dotProductVector[1] );
+++ dotProduct += (dotProductVector[0] + dotProductVector[1]);
++
++- if(isodd) {
++- dotProduct += input[num_points - 1] * taps[num_points - 1];
++- }
+++ if (isodd) {
+++ dotProduct += input[num_points - 1] * taps[num_points - 1];
+++ }
++
++- *result = dotProduct;
+++ *result = dotProduct;
++ }
++
++ #endif /*LV_HAVE_SSE3*/
++@@ -296,78 +306,82 @@ static inline void volk_32fc_x2_dot_prod_32fc_u_sse3(lv_32fc_t* result, const lv
++
++ #include <smmintrin.h>
++
++-static inline void volk_32fc_x2_dot_prod_32fc_u_sse4_1(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_u_sse4_1(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- unsigned int i = 0;
++- const unsigned int qtr_points = num_points/4;
++- const unsigned int isodd = num_points & 3;
+++ unsigned int i = 0;
+++ const unsigned int qtr_points = num_points / 4;
+++ const unsigned int isodd = num_points & 3;
++
++- __m128 xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, real0, real1, im0, im1;
++- float *p_input, *p_taps;
++- __m64 *p_result;
+++ __m128 xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, real0, real1, im0, im1;
+++ float *p_input, *p_taps;
+++ __m64* p_result;
++
++- p_result = (__m64*)result;
++- p_input = (float*)input;
++- p_taps = (float*)taps;
+++ p_result = (__m64*)result;
+++ p_input = (float*)input;
+++ p_taps = (float*)taps;
++
++- static const __m128i neg = {0x000000000000000080000000};
+++ static const __m128i neg = { 0x000000000000000080000000 };
++
++- real0 = _mm_setzero_ps();
++- real1 = _mm_setzero_ps();
++- im0 = _mm_setzero_ps();
++- im1 = _mm_setzero_ps();
+++ real0 = _mm_setzero_ps();
+++ real1 = _mm_setzero_ps();
+++ im0 = _mm_setzero_ps();
+++ im1 = _mm_setzero_ps();
++
++- for(; i < qtr_points; ++i) {
++- xmm0 = _mm_loadu_ps(p_input);
++- xmm1 = _mm_loadu_ps(p_taps);
+++ for (; i < qtr_points; ++i) {
+++ xmm0 = _mm_loadu_ps(p_input);
+++ xmm1 = _mm_loadu_ps(p_taps);
++
++- p_input += 4;
++- p_taps += 4;
+++ p_input += 4;
+++ p_taps += 4;
++
++- xmm2 = _mm_loadu_ps(p_input);
++- xmm3 = _mm_loadu_ps(p_taps);
+++ xmm2 = _mm_loadu_ps(p_input);
+++ xmm3 = _mm_loadu_ps(p_taps);
++
++- p_input += 4;
++- p_taps += 4;
+++ p_input += 4;
+++ p_taps += 4;
++
++- xmm4 = _mm_unpackhi_ps(xmm0, xmm2);
++- xmm5 = _mm_unpackhi_ps(xmm1, xmm3);
++- xmm0 = _mm_unpacklo_ps(xmm0, xmm2);
++- xmm2 = _mm_unpacklo_ps(xmm1, xmm3);
+++ xmm4 = _mm_unpackhi_ps(xmm0, xmm2);
+++ xmm5 = _mm_unpackhi_ps(xmm1, xmm3);
+++ xmm0 = _mm_unpacklo_ps(xmm0, xmm2);
+++ xmm2 = _mm_unpacklo_ps(xmm1, xmm3);
++
++- //imaginary vector from input
++- xmm1 = _mm_unpackhi_ps(xmm0, xmm4);
++- //real vector from input
++- xmm3 = _mm_unpacklo_ps(xmm0, xmm4);
++- //imaginary vector from taps
++- xmm0 = _mm_unpackhi_ps(xmm2, xmm5);
++- //real vector from taps
++- xmm2 = _mm_unpacklo_ps(xmm2, xmm5);
+++ // imaginary vector from input
+++ xmm1 = _mm_unpackhi_ps(xmm0, xmm4);
+++ // real vector from input
+++ xmm3 = _mm_unpacklo_ps(xmm0, xmm4);
+++ // imaginary vector from taps
+++ xmm0 = _mm_unpackhi_ps(xmm2, xmm5);
+++ // real vector from taps
+++ xmm2 = _mm_unpacklo_ps(xmm2, xmm5);
++
++- xmm4 = _mm_dp_ps(xmm3, xmm2, 0xf1);
++- xmm5 = _mm_dp_ps(xmm1, xmm0, 0xf1);
+++ xmm4 = _mm_dp_ps(xmm3, xmm2, 0xf1);
+++ xmm5 = _mm_dp_ps(xmm1, xmm0, 0xf1);
++
++- xmm6 = _mm_dp_ps(xmm3, xmm0, 0xf2);
++- xmm7 = _mm_dp_ps(xmm1, xmm2, 0xf2);
+++ xmm6 = _mm_dp_ps(xmm3, xmm0, 0xf2);
+++ xmm7 = _mm_dp_ps(xmm1, xmm2, 0xf2);
++
++- real0 = _mm_add_ps(xmm4, real0);
++- real1 = _mm_add_ps(xmm5, real1);
++- im0 = _mm_add_ps(xmm6, im0);
++- im1 = _mm_add_ps(xmm7, im1);
++- }
+++ real0 = _mm_add_ps(xmm4, real0);
+++ real1 = _mm_add_ps(xmm5, real1);
+++ im0 = _mm_add_ps(xmm6, im0);
+++ im1 = _mm_add_ps(xmm7, im1);
+++ }
++
++- real1 = _mm_xor_ps(real1, bit128_p(&neg)->float_vec);
+++ real1 = _mm_xor_ps(real1, bit128_p(&neg)->float_vec);
++
++- im0 = _mm_add_ps(im0, im1);
++- real0 = _mm_add_ps(real0, real1);
+++ im0 = _mm_add_ps(im0, im1);
+++ real0 = _mm_add_ps(real0, real1);
++
++- im0 = _mm_add_ps(im0, real0);
+++ im0 = _mm_add_ps(im0, real0);
++
++- _mm_storel_pi(p_result, im0);
+++ _mm_storel_pi(p_result, im0);
++
++- for(i = num_points-isodd; i < num_points; i++) {
++- *result += input[i] * taps[i];
++- }
+++ for (i = num_points - isodd; i < num_points; i++) {
+++ *result += input[i] * taps[i];
+++ }
++ }
++
++ #endif /*LV_HAVE_SSE4_1*/
++@@ -376,55 +390,63 @@ static inline void volk_32fc_x2_dot_prod_32fc_u_sse4_1(lv_32fc_t* result, const
++
++ #include <immintrin.h>
++
++-static inline void volk_32fc_x2_dot_prod_32fc_u_avx(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_u_avx(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- unsigned int isodd = num_points & 3;
++- unsigned int i = 0;
++- lv_32fc_t dotProduct;
++- memset(&dotProduct, 0x0, 2*sizeof(float));
+++ unsigned int isodd = num_points & 3;
+++ unsigned int i = 0;
+++ lv_32fc_t dotProduct;
+++ memset(&dotProduct, 0x0, 2 * sizeof(float));
++
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- __m256 x, y, yl, yh, z, tmp1, tmp2, dotProdVal;
+++ __m256 x, y, yl, yh, z, tmp1, tmp2, dotProdVal;
++
++- const lv_32fc_t* a = input;
++- const lv_32fc_t* b = taps;
+++ const lv_32fc_t* a = input;
+++ const lv_32fc_t* b = taps;
++
++- dotProdVal = _mm256_setzero_ps();
+++ dotProdVal = _mm256_setzero_ps();
++
++- for(;number < quarterPoints; number++){
++- x = _mm256_loadu_ps((float*)a); // Load a,b,e,f as ar,ai,br,bi,er,ei,fr,fi
++- y = _mm256_loadu_ps((float*)b); // Load c,d,g,h as cr,ci,dr,di,gr,gi,hr,hi
+++ for (; number < quarterPoints; number++) {
+++ x = _mm256_loadu_ps((float*)a); // Load a,b,e,f as ar,ai,br,bi,er,ei,fr,fi
+++ y = _mm256_loadu_ps((float*)b); // Load c,d,g,h as cr,ci,dr,di,gr,gi,hr,hi
++
++- yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr,gr,gr,hr,hr
++- yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di,gi,gi,hi,hi
+++ yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr,gr,gr,hr,hr
+++ yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di,gi,gi,hi,hi
++
++- tmp1 = _mm256_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr ...
+++ tmp1 = _mm256_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr ...
++
++- x = _mm256_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br,ei,er,fi,fr
+++ x = _mm256_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br,ei,er,fi,fr
++
++- tmp2 = _mm256_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di ...
+++ tmp2 = _mm256_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di ...
++
++- z = _mm256_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ z = _mm256_addsub_ps(tmp1,
+++ tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- dotProdVal = _mm256_add_ps(dotProdVal, z); // Add the complex multiplication results together
+++ dotProdVal = _mm256_add_ps(dotProdVal,
+++ z); // Add the complex multiplication results together
++
++- a += 4;
++- b += 4;
++- }
+++ a += 4;
+++ b += 4;
+++ }
++
++- __VOLK_ATTR_ALIGNED(32) lv_32fc_t dotProductVector[4];
+++ __VOLK_ATTR_ALIGNED(32) lv_32fc_t dotProductVector[4];
++
++- _mm256_storeu_ps((float*)dotProductVector,dotProdVal); // Store the results back into the dot product vector
+++ _mm256_storeu_ps((float*)dotProductVector,
+++ dotProdVal); // Store the results back into the dot product vector
++
++- dotProduct += ( dotProductVector[0] + dotProductVector[1] + dotProductVector[2] + dotProductVector[3]);
+++ dotProduct += (dotProductVector[0] + dotProductVector[1] + dotProductVector[2] +
+++ dotProductVector[3]);
++
++- for(i = num_points-isodd; i < num_points; i++) {
++- dotProduct += input[i] * taps[i];
++- }
+++ for (i = num_points - isodd; i < num_points; i++) {
+++ dotProduct += input[i] * taps[i];
+++ }
++
++- *result = dotProduct;
+++ *result = dotProduct;
++ }
++
++ #endif /*LV_HAVE_AVX*/
++@@ -432,56 +454,64 @@ static inline void volk_32fc_x2_dot_prod_32fc_u_avx(lv_32fc_t* result, const lv_
++ #if LV_HAVE_AVX && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void volk_32fc_x2_dot_prod_32fc_u_avx_fma(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_u_avx_fma(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- unsigned int isodd = num_points & 3;
++- unsigned int i = 0;
++- lv_32fc_t dotProduct;
++- memset(&dotProduct, 0x0, 2*sizeof(float));
+++ unsigned int isodd = num_points & 3;
+++ unsigned int i = 0;
+++ lv_32fc_t dotProduct;
+++ memset(&dotProduct, 0x0, 2 * sizeof(float));
++
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- __m256 x, y, yl, yh, z, tmp1, tmp2, dotProdVal;
+++ __m256 x, y, yl, yh, z, tmp1, tmp2, dotProdVal;
++
++- const lv_32fc_t* a = input;
++- const lv_32fc_t* b = taps;
+++ const lv_32fc_t* a = input;
+++ const lv_32fc_t* b = taps;
++
++- dotProdVal = _mm256_setzero_ps();
+++ dotProdVal = _mm256_setzero_ps();
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- x = _mm256_loadu_ps((float*)a); // Load a,b,e,f as ar,ai,br,bi,er,ei,fr,fi
++- y = _mm256_loadu_ps((float*)b); // Load c,d,g,h as cr,ci,dr,di,gr,gi,hr,hi
+++ x = _mm256_loadu_ps((float*)a); // Load a,b,e,f as ar,ai,br,bi,er,ei,fr,fi
+++ y = _mm256_loadu_ps((float*)b); // Load c,d,g,h as cr,ci,dr,di,gr,gi,hr,hi
++
++- yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr,gr,gr,hr,hr
++- yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di,gi,gi,hi,hi
+++ yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr,gr,gr,hr,hr
+++ yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di,gi,gi,hi,hi
++
++- tmp1 = x;
+++ tmp1 = x;
++
++- x = _mm256_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br,ei,er,fi,fr
+++ x = _mm256_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br,ei,er,fi,fr
++
++- tmp2 = _mm256_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di ...
+++ tmp2 = _mm256_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di ...
++
++- z = _mm256_fmaddsub_ps(tmp1, yl,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ z = _mm256_fmaddsub_ps(
+++ tmp1, yl, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- dotProdVal = _mm256_add_ps(dotProdVal, z); // Add the complex multiplication results together
+++ dotProdVal = _mm256_add_ps(dotProdVal,
+++ z); // Add the complex multiplication results together
++
++- a += 4;
++- b += 4;
++- }
+++ a += 4;
+++ b += 4;
+++ }
++
++- __VOLK_ATTR_ALIGNED(32) lv_32fc_t dotProductVector[4];
+++ __VOLK_ATTR_ALIGNED(32) lv_32fc_t dotProductVector[4];
++
++- _mm256_storeu_ps((float*)dotProductVector,dotProdVal); // Store the results back into the dot product vector
+++ _mm256_storeu_ps((float*)dotProductVector,
+++ dotProdVal); // Store the results back into the dot product vector
++
++- dotProduct += ( dotProductVector[0] + dotProductVector[1] + dotProductVector[2] + dotProductVector[3]);
+++ dotProduct += (dotProductVector[0] + dotProductVector[1] + dotProductVector[2] +
+++ dotProductVector[3]);
++
++- for(i = num_points-isodd; i < num_points; i++) {
++- dotProduct += input[i] * taps[i];
++- }
+++ for (i = num_points - isodd; i < num_points; i++) {
+++ dotProduct += input[i] * taps[i];
+++ }
++
++- *result = dotProduct;
+++ *result = dotProduct;
++ }
++
++ #endif /*LV_HAVE_AVX && LV_HAVE_FMA*/
++@@ -491,44 +521,48 @@ static inline void volk_32fc_x2_dot_prod_32fc_u_avx_fma(lv_32fc_t* result, const
++ #ifndef INCLUDED_volk_32fc_x2_dot_prod_32fc_a_H
++ #define INCLUDED_volk_32fc_x2_dot_prod_32fc_a_H
++
++-#include <volk/volk_common.h>
++-#include <volk/volk_complex.h>
++ #include <stdio.h>
++ #include <string.h>
+++#include <volk/volk_common.h>
+++#include <volk/volk_complex.h>
++
++
++ #ifdef LV_HAVE_GENERIC
++
++
++-static inline void volk_32fc_x2_dot_prod_32fc_a_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_a_generic(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- const unsigned int num_bytes = num_points*8;
+++ const unsigned int num_bytes = num_points * 8;
++
++- float * res = (float*) result;
++- float * in = (float*) input;
++- float * tp = (float*) taps;
++- unsigned int n_2_ccomplex_blocks = num_bytes >> 4;
+++ float* res = (float*)result;
+++ float* in = (float*)input;
+++ float* tp = (float*)taps;
+++ unsigned int n_2_ccomplex_blocks = num_bytes >> 4;
++
++- float sum0[2] = {0,0};
++- float sum1[2] = {0,0};
++- unsigned int i = 0;
+++ float sum0[2] = { 0, 0 };
+++ float sum1[2] = { 0, 0 };
+++ unsigned int i = 0;
++
++- for(i = 0; i < n_2_ccomplex_blocks; ++i) {
++- sum0[0] += in[0] * tp[0] - in[1] * tp[1];
++- sum0[1] += in[0] * tp[1] + in[1] * tp[0];
++- sum1[0] += in[2] * tp[2] - in[3] * tp[3];
++- sum1[1] += in[2] * tp[3] + in[3] * tp[2];
+++ for (i = 0; i < n_2_ccomplex_blocks; ++i) {
+++ sum0[0] += in[0] * tp[0] - in[1] * tp[1];
+++ sum0[1] += in[0] * tp[1] + in[1] * tp[0];
+++ sum1[0] += in[2] * tp[2] - in[3] * tp[3];
+++ sum1[1] += in[2] * tp[3] + in[3] * tp[2];
++
++- in += 4;
++- tp += 4;
++- }
+++ in += 4;
+++ tp += 4;
+++ }
++
++- res[0] = sum0[0] + sum1[0];
++- res[1] = sum0[1] + sum1[1];
+++ res[0] = sum0[0] + sum1[0];
+++ res[1] = sum0[1] + sum1[1];
++
++- if (num_points & 1) {
++- *result += input[num_points - 1] * taps[num_points - 1];
++- }
+++ if (num_points & 1) {
+++ *result += input[num_points - 1] * taps[num_points - 1];
+++ }
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -537,140 +571,146 @@ static inline void volk_32fc_x2_dot_prod_32fc_a_generic(lv_32fc_t* result, const
++ #if LV_HAVE_SSE && LV_HAVE_64
++
++
++-static inline void volk_32fc_x2_dot_prod_32fc_a_sse_64(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
++-
++- const unsigned int num_bytes = num_points*8;
++- unsigned int isodd = num_points & 1;
++-
++- __VOLK_ASM
++- (
++- "# ccomplex_dotprod_generic (float* result, const float *input,\n\t"
++- "# const float *taps, unsigned num_bytes)\n\t"
++- "# float sum0 = 0;\n\t"
++- "# float sum1 = 0;\n\t"
++- "# float sum2 = 0;\n\t"
++- "# float sum3 = 0;\n\t"
++- "# do {\n\t"
++- "# sum0 += input[0] * taps[0] - input[1] * taps[1];\n\t"
++- "# sum1 += input[0] * taps[1] + input[1] * taps[0];\n\t"
++- "# sum2 += input[2] * taps[2] - input[3] * taps[3];\n\t"
++- "# sum3 += input[2] * taps[3] + input[3] * taps[2];\n\t"
++- "# input += 4;\n\t"
++- "# taps += 4; \n\t"
++- "# } while (--n_2_ccomplex_blocks != 0);\n\t"
++- "# result[0] = sum0 + sum2;\n\t"
++- "# result[1] = sum1 + sum3;\n\t"
++- "# TODO: prefetch and better scheduling\n\t"
++- " xor %%r9, %%r9\n\t"
++- " xor %%r10, %%r10\n\t"
++- " movq %%rcx, %%rax\n\t"
++- " movq %%rcx, %%r8\n\t"
++- " movq %[rsi], %%r9\n\t"
++- " movq %[rdx], %%r10\n\t"
++- " xorps %%xmm6, %%xmm6 # zero accumulators\n\t"
++- " movaps 0(%%r9), %%xmm0\n\t"
++- " xorps %%xmm7, %%xmm7 # zero accumulators\n\t"
++- " movaps 0(%%r10), %%xmm2\n\t"
++- " shr $5, %%rax # rax = n_2_ccomplex_blocks / 2\n\t"
++- " shr $4, %%r8\n\t"
++- " jmp .%=L1_test\n\t"
++- " # 4 taps / loop\n\t"
++- " # something like ?? cycles / loop\n\t"
++- ".%=Loop1: \n\t"
++- "# complex prod: C += A * B, w/ temp Z & Y (or B), xmmPN=$0x8000000080000000\n\t"
++- "# movaps (%%r9), %%xmmA\n\t"
++- "# movaps (%%r10), %%xmmB\n\t"
++- "# movaps %%xmmA, %%xmmZ\n\t"
++- "# shufps $0xb1, %%xmmZ, %%xmmZ # swap internals\n\t"
++- "# mulps %%xmmB, %%xmmA\n\t"
++- "# mulps %%xmmZ, %%xmmB\n\t"
++- "# # SSE replacement for: pfpnacc %%xmmB, %%xmmA\n\t"
++- "# xorps %%xmmPN, %%xmmA\n\t"
++- "# movaps %%xmmA, %%xmmZ\n\t"
++- "# unpcklps %%xmmB, %%xmmA\n\t"
++- "# unpckhps %%xmmB, %%xmmZ\n\t"
++- "# movaps %%xmmZ, %%xmmY\n\t"
++- "# shufps $0x44, %%xmmA, %%xmmZ # b01000100\n\t"
++- "# shufps $0xee, %%xmmY, %%xmmA # b11101110\n\t"
++- "# addps %%xmmZ, %%xmmA\n\t"
++- "# addps %%xmmA, %%xmmC\n\t"
++- "# A=xmm0, B=xmm2, Z=xmm4\n\t"
++- "# A'=xmm1, B'=xmm3, Z'=xmm5\n\t"
++- " movaps 16(%%r9), %%xmm1\n\t"
++- " movaps %%xmm0, %%xmm4\n\t"
++- " mulps %%xmm2, %%xmm0\n\t"
++- " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
++- " movaps 16(%%r10), %%xmm3\n\t"
++- " movaps %%xmm1, %%xmm5\n\t"
++- " addps %%xmm0, %%xmm6\n\t"
++- " mulps %%xmm3, %%xmm1\n\t"
++- " shufps $0xb1, %%xmm5, %%xmm5 # swap internals\n\t"
++- " addps %%xmm1, %%xmm6\n\t"
++- " mulps %%xmm4, %%xmm2\n\t"
++- " movaps 32(%%r9), %%xmm0\n\t"
++- " addps %%xmm2, %%xmm7\n\t"
++- " mulps %%xmm5, %%xmm3\n\t"
++- " add $32, %%r9\n\t"
++- " movaps 32(%%r10), %%xmm2\n\t"
++- " addps %%xmm3, %%xmm7\n\t"
++- " add $32, %%r10\n\t"
++- ".%=L1_test:\n\t"
++- " dec %%rax\n\t"
++- " jge .%=Loop1\n\t"
++- " # We've handled the bulk of multiplies up to here.\n\t"
++- " # Let's sse if original n_2_ccomplex_blocks was odd.\n\t"
++- " # If so, we've got 2 more taps to do.\n\t"
++- " and $1, %%r8\n\t"
++- " je .%=Leven\n\t"
++- " # The count was odd, do 2 more taps.\n\t"
++- " # Note that we've already got mm0/mm2 preloaded\n\t"
++- " # from the main loop.\n\t"
++- " movaps %%xmm0, %%xmm4\n\t"
++- " mulps %%xmm2, %%xmm0\n\t"
++- " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
++- " addps %%xmm0, %%xmm6\n\t"
++- " mulps %%xmm4, %%xmm2\n\t"
++- " addps %%xmm2, %%xmm7\n\t"
++- ".%=Leven:\n\t"
++- " # neg inversor\n\t"
++- " xorps %%xmm1, %%xmm1\n\t"
++- " mov $0x80000000, %%r9\n\t"
++- " movd %%r9, %%xmm1\n\t"
++- " shufps $0x11, %%xmm1, %%xmm1 # b00010001 # 0 -0 0 -0\n\t"
++- " # pfpnacc\n\t"
++- " xorps %%xmm1, %%xmm6\n\t"
++- " movaps %%xmm6, %%xmm2\n\t"
++- " unpcklps %%xmm7, %%xmm6\n\t"
++- " unpckhps %%xmm7, %%xmm2\n\t"
++- " movaps %%xmm2, %%xmm3\n\t"
++- " shufps $0x44, %%xmm6, %%xmm2 # b01000100\n\t"
++- " shufps $0xee, %%xmm3, %%xmm6 # b11101110\n\t"
++- " addps %%xmm2, %%xmm6\n\t"
++- " # xmm6 = r1 i2 r3 i4\n\t"
++- " movhlps %%xmm6, %%xmm4 # xmm4 = r3 i4 ?? ??\n\t"
++- " addps %%xmm4, %%xmm6 # xmm6 = r1+r3 i2+i4 ?? ??\n\t"
++- " movlps %%xmm6, (%[rdi]) # store low 2x32 bits (complex) to memory\n\t"
++- :
++- :[rsi] "r" (input), [rdx] "r" (taps), "c" (num_bytes), [rdi] "r" (result)
++- :"rax", "r8", "r9", "r10"
++- );
++-
++-
++- if(isodd) {
++- *result += input[num_points - 1] * taps[num_points - 1];
++- }
++-
++- return;
+++static inline void volk_32fc_x2_dot_prod_32fc_a_sse_64(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
+++
+++ const unsigned int num_bytes = num_points * 8;
+++ unsigned int isodd = num_points & 1;
+++
+++ __VOLK_ASM(
+++ "# ccomplex_dotprod_generic (float* result, const float *input,\n\t"
+++ "# const float *taps, unsigned num_bytes)\n\t"
+++ "# float sum0 = 0;\n\t"
+++ "# float sum1 = 0;\n\t"
+++ "# float sum2 = 0;\n\t"
+++ "# float sum3 = 0;\n\t"
+++ "# do {\n\t"
+++ "# sum0 += input[0] * taps[0] - input[1] * taps[1];\n\t"
+++ "# sum1 += input[0] * taps[1] + input[1] * taps[0];\n\t"
+++ "# sum2 += input[2] * taps[2] - input[3] * taps[3];\n\t"
+++ "# sum3 += input[2] * taps[3] + input[3] * taps[2];\n\t"
+++ "# input += 4;\n\t"
+++ "# taps += 4; \n\t"
+++ "# } while (--n_2_ccomplex_blocks != 0);\n\t"
+++ "# result[0] = sum0 + sum2;\n\t"
+++ "# result[1] = sum1 + sum3;\n\t"
+++ "# TODO: prefetch and better scheduling\n\t"
+++ " xor %%r9, %%r9\n\t"
+++ " xor %%r10, %%r10\n\t"
+++ " movq %%rcx, %%rax\n\t"
+++ " movq %%rcx, %%r8\n\t"
+++ " movq %[rsi], %%r9\n\t"
+++ " movq %[rdx], %%r10\n\t"
+++ " xorps %%xmm6, %%xmm6 # zero accumulators\n\t"
+++ " movaps 0(%%r9), %%xmm0\n\t"
+++ " xorps %%xmm7, %%xmm7 # zero accumulators\n\t"
+++ " movaps 0(%%r10), %%xmm2\n\t"
+++ " shr $5, %%rax # rax = n_2_ccomplex_blocks / 2\n\t"
+++ " shr $4, %%r8\n\t"
+++ " jmp .%=L1_test\n\t"
+++ " # 4 taps / loop\n\t"
+++ " # something like ?? cycles / loop\n\t"
+++ ".%=Loop1: \n\t"
+++ "# complex prod: C += A * B, w/ temp Z & Y (or B), xmmPN=$0x8000000080000000\n\t"
+++ "# movaps (%%r9), %%xmmA\n\t"
+++ "# movaps (%%r10), %%xmmB\n\t"
+++ "# movaps %%xmmA, %%xmmZ\n\t"
+++ "# shufps $0xb1, %%xmmZ, %%xmmZ # swap internals\n\t"
+++ "# mulps %%xmmB, %%xmmA\n\t"
+++ "# mulps %%xmmZ, %%xmmB\n\t"
+++ "# # SSE replacement for: pfpnacc %%xmmB, %%xmmA\n\t"
+++ "# xorps %%xmmPN, %%xmmA\n\t"
+++ "# movaps %%xmmA, %%xmmZ\n\t"
+++ "# unpcklps %%xmmB, %%xmmA\n\t"
+++ "# unpckhps %%xmmB, %%xmmZ\n\t"
+++ "# movaps %%xmmZ, %%xmmY\n\t"
+++ "# shufps $0x44, %%xmmA, %%xmmZ # b01000100\n\t"
+++ "# shufps $0xee, %%xmmY, %%xmmA # b11101110\n\t"
+++ "# addps %%xmmZ, %%xmmA\n\t"
+++ "# addps %%xmmA, %%xmmC\n\t"
+++ "# A=xmm0, B=xmm2, Z=xmm4\n\t"
+++ "# A'=xmm1, B'=xmm3, Z'=xmm5\n\t"
+++ " movaps 16(%%r9), %%xmm1\n\t"
+++ " movaps %%xmm0, %%xmm4\n\t"
+++ " mulps %%xmm2, %%xmm0\n\t"
+++ " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
+++ " movaps 16(%%r10), %%xmm3\n\t"
+++ " movaps %%xmm1, %%xmm5\n\t"
+++ " addps %%xmm0, %%xmm6\n\t"
+++ " mulps %%xmm3, %%xmm1\n\t"
+++ " shufps $0xb1, %%xmm5, %%xmm5 # swap internals\n\t"
+++ " addps %%xmm1, %%xmm6\n\t"
+++ " mulps %%xmm4, %%xmm2\n\t"
+++ " movaps 32(%%r9), %%xmm0\n\t"
+++ " addps %%xmm2, %%xmm7\n\t"
+++ " mulps %%xmm5, %%xmm3\n\t"
+++ " add $32, %%r9\n\t"
+++ " movaps 32(%%r10), %%xmm2\n\t"
+++ " addps %%xmm3, %%xmm7\n\t"
+++ " add $32, %%r10\n\t"
+++ ".%=L1_test:\n\t"
+++ " dec %%rax\n\t"
+++ " jge .%=Loop1\n\t"
+++ " # We've handled the bulk of multiplies up to here.\n\t"
+++ " # Let's sse if original n_2_ccomplex_blocks was odd.\n\t"
+++ " # If so, we've got 2 more taps to do.\n\t"
+++ " and $1, %%r8\n\t"
+++ " je .%=Leven\n\t"
+++ " # The count was odd, do 2 more taps.\n\t"
+++ " # Note that we've already got mm0/mm2 preloaded\n\t"
+++ " # from the main loop.\n\t"
+++ " movaps %%xmm0, %%xmm4\n\t"
+++ " mulps %%xmm2, %%xmm0\n\t"
+++ " shufps $0xb1, %%xmm4, %%xmm4 # swap internals\n\t"
+++ " addps %%xmm0, %%xmm6\n\t"
+++ " mulps %%xmm4, %%xmm2\n\t"
+++ " addps %%xmm2, %%xmm7\n\t"
+++ ".%=Leven:\n\t"
+++ " # neg inversor\n\t"
+++ " xorps %%xmm1, %%xmm1\n\t"
+++ " mov $0x80000000, %%r9\n\t"
+++ " movd %%r9, %%xmm1\n\t"
+++ " shufps $0x11, %%xmm1, %%xmm1 # b00010001 # 0 -0 0 -0\n\t"
+++ " # pfpnacc\n\t"
+++ " xorps %%xmm1, %%xmm6\n\t"
+++ " movaps %%xmm6, %%xmm2\n\t"
+++ " unpcklps %%xmm7, %%xmm6\n\t"
+++ " unpckhps %%xmm7, %%xmm2\n\t"
+++ " movaps %%xmm2, %%xmm3\n\t"
+++ " shufps $0x44, %%xmm6, %%xmm2 # b01000100\n\t"
+++ " shufps $0xee, %%xmm3, %%xmm6 # b11101110\n\t"
+++ " addps %%xmm2, %%xmm6\n\t"
+++ " # xmm6 = r1 i2 r3 i4\n\t"
+++ " movhlps %%xmm6, %%xmm4 # xmm4 = r3 i4 ?? ??\n\t"
+++ " addps %%xmm4, %%xmm6 # xmm6 = r1+r3 i2+i4 ?? ??\n\t"
+++ " movlps %%xmm6, (%[rdi]) # store low 2x32 bits (complex) "
+++ "to memory\n\t"
+++ :
+++ : [rsi] "r"(input), [rdx] "r"(taps), "c"(num_bytes), [rdi] "r"(result)
+++ : "rax", "r8", "r9", "r10");
+++
+++
+++ if (isodd) {
+++ *result += input[num_points - 1] * taps[num_points - 1];
+++ }
++
+++ return;
++ }
++
++ #endif
++
++ #if LV_HAVE_SSE && LV_HAVE_32
++
++-static inline void volk_32fc_x2_dot_prod_32fc_a_sse_32(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_a_sse_32(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- volk_32fc_x2_dot_prod_32fc_a_generic(result, input, taps, num_points);
+++ volk_32fc_x2_dot_prod_32fc_a_generic(result, input, taps, num_points);
++
++ #if 0
++ const unsigned int num_bytes = num_points*8;
++@@ -792,57 +832,64 @@ static inline void volk_32fc_x2_dot_prod_32fc_a_sse_32(lv_32fc_t* result, const
++
++ #include <pmmintrin.h>
++
++-static inline void volk_32fc_x2_dot_prod_32fc_a_sse3(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_a_sse3(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- const unsigned int num_bytes = num_points*8;
++- unsigned int isodd = num_points & 1;
+++ const unsigned int num_bytes = num_points * 8;
+++ unsigned int isodd = num_points & 1;
++
++- lv_32fc_t dotProduct;
++- memset(&dotProduct, 0x0, 2*sizeof(float));
+++ lv_32fc_t dotProduct;
+++ memset(&dotProduct, 0x0, 2 * sizeof(float));
++
++- unsigned int number = 0;
++- const unsigned int halfPoints = num_bytes >> 4;
+++ unsigned int number = 0;
+++ const unsigned int halfPoints = num_bytes >> 4;
++
++- __m128 x, y, yl, yh, z, tmp1, tmp2, dotProdVal;
+++ __m128 x, y, yl, yh, z, tmp1, tmp2, dotProdVal;
++
++- const lv_32fc_t* a = input;
++- const lv_32fc_t* b = taps;
+++ const lv_32fc_t* a = input;
+++ const lv_32fc_t* b = taps;
++
++- dotProdVal = _mm_setzero_ps();
+++ dotProdVal = _mm_setzero_ps();
++
++- for(;number < halfPoints; number++){
+++ for (; number < halfPoints; number++) {
++
++- x = _mm_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
++- y = _mm_load_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di
+++ x = _mm_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ y = _mm_load_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di
++
++- yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr
++- yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di
+++ yl = _mm_moveldup_ps(y); // Load yl with cr,cr,dr,dr
+++ yh = _mm_movehdup_ps(y); // Load yh with ci,ci,di,di
++
++- tmp1 = _mm_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
+++ tmp1 = _mm_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr
++
++- x = _mm_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br
+++ x = _mm_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br
++
++- tmp2 = _mm_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+++ tmp2 = _mm_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
++
++- z = _mm_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ z = _mm_addsub_ps(tmp1,
+++ tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- dotProdVal = _mm_add_ps(dotProdVal, z); // Add the complex multiplication results together
+++ dotProdVal =
+++ _mm_add_ps(dotProdVal, z); // Add the complex multiplication results together
++
++- a += 2;
++- b += 2;
++- }
+++ a += 2;
+++ b += 2;
+++ }
++
++- __VOLK_ATTR_ALIGNED(16) lv_32fc_t dotProductVector[2];
+++ __VOLK_ATTR_ALIGNED(16) lv_32fc_t dotProductVector[2];
++
++- _mm_store_ps((float*)dotProductVector,dotProdVal); // Store the results back into the dot product vector
+++ _mm_store_ps((float*)dotProductVector,
+++ dotProdVal); // Store the results back into the dot product vector
++
++- dotProduct += ( dotProductVector[0] + dotProductVector[1] );
+++ dotProduct += (dotProductVector[0] + dotProductVector[1]);
++
++- if(isodd) {
++- dotProduct += input[num_points - 1] * taps[num_points - 1];
++- }
+++ if (isodd) {
+++ dotProduct += input[num_points - 1] * taps[num_points - 1];
+++ }
++
++- *result = dotProduct;
+++ *result = dotProduct;
++ }
++
++ #endif /*LV_HAVE_SSE3*/
++@@ -852,78 +899,82 @@ static inline void volk_32fc_x2_dot_prod_32fc_a_sse3(lv_32fc_t* result, const lv
++
++ #include <smmintrin.h>
++
++-static inline void volk_32fc_x2_dot_prod_32fc_a_sse4_1(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_a_sse4_1(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- unsigned int i = 0;
++- const unsigned int qtr_points = num_points/4;
++- const unsigned int isodd = num_points & 3;
+++ unsigned int i = 0;
+++ const unsigned int qtr_points = num_points / 4;
+++ const unsigned int isodd = num_points & 3;
++
++- __m128 xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, real0, real1, im0, im1;
++- float *p_input, *p_taps;
++- __m64 *p_result;
+++ __m128 xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, real0, real1, im0, im1;
+++ float *p_input, *p_taps;
+++ __m64* p_result;
++
++- static const __m128i neg = {0x000000000000000080000000};
+++ static const __m128i neg = { 0x000000000000000080000000 };
++
++- p_result = (__m64*)result;
++- p_input = (float*)input;
++- p_taps = (float*)taps;
+++ p_result = (__m64*)result;
+++ p_input = (float*)input;
+++ p_taps = (float*)taps;
++
++- real0 = _mm_setzero_ps();
++- real1 = _mm_setzero_ps();
++- im0 = _mm_setzero_ps();
++- im1 = _mm_setzero_ps();
+++ real0 = _mm_setzero_ps();
+++ real1 = _mm_setzero_ps();
+++ im0 = _mm_setzero_ps();
+++ im1 = _mm_setzero_ps();
++
++- for(; i < qtr_points; ++i) {
++- xmm0 = _mm_load_ps(p_input);
++- xmm1 = _mm_load_ps(p_taps);
+++ for (; i < qtr_points; ++i) {
+++ xmm0 = _mm_load_ps(p_input);
+++ xmm1 = _mm_load_ps(p_taps);
++
++- p_input += 4;
++- p_taps += 4;
+++ p_input += 4;
+++ p_taps += 4;
++
++- xmm2 = _mm_load_ps(p_input);
++- xmm3 = _mm_load_ps(p_taps);
+++ xmm2 = _mm_load_ps(p_input);
+++ xmm3 = _mm_load_ps(p_taps);
++
++- p_input += 4;
++- p_taps += 4;
+++ p_input += 4;
+++ p_taps += 4;
++
++- xmm4 = _mm_unpackhi_ps(xmm0, xmm2);
++- xmm5 = _mm_unpackhi_ps(xmm1, xmm3);
++- xmm0 = _mm_unpacklo_ps(xmm0, xmm2);
++- xmm2 = _mm_unpacklo_ps(xmm1, xmm3);
+++ xmm4 = _mm_unpackhi_ps(xmm0, xmm2);
+++ xmm5 = _mm_unpackhi_ps(xmm1, xmm3);
+++ xmm0 = _mm_unpacklo_ps(xmm0, xmm2);
+++ xmm2 = _mm_unpacklo_ps(xmm1, xmm3);
++
++- //imaginary vector from input
++- xmm1 = _mm_unpackhi_ps(xmm0, xmm4);
++- //real vector from input
++- xmm3 = _mm_unpacklo_ps(xmm0, xmm4);
++- //imaginary vector from taps
++- xmm0 = _mm_unpackhi_ps(xmm2, xmm5);
++- //real vector from taps
++- xmm2 = _mm_unpacklo_ps(xmm2, xmm5);
+++ // imaginary vector from input
+++ xmm1 = _mm_unpackhi_ps(xmm0, xmm4);
+++ // real vector from input
+++ xmm3 = _mm_unpacklo_ps(xmm0, xmm4);
+++ // imaginary vector from taps
+++ xmm0 = _mm_unpackhi_ps(xmm2, xmm5);
+++ // real vector from taps
+++ xmm2 = _mm_unpacklo_ps(xmm2, xmm5);
++
++- xmm4 = _mm_dp_ps(xmm3, xmm2, 0xf1);
++- xmm5 = _mm_dp_ps(xmm1, xmm0, 0xf1);
+++ xmm4 = _mm_dp_ps(xmm3, xmm2, 0xf1);
+++ xmm5 = _mm_dp_ps(xmm1, xmm0, 0xf1);
++
++- xmm6 = _mm_dp_ps(xmm3, xmm0, 0xf2);
++- xmm7 = _mm_dp_ps(xmm1, xmm2, 0xf2);
+++ xmm6 = _mm_dp_ps(xmm3, xmm0, 0xf2);
+++ xmm7 = _mm_dp_ps(xmm1, xmm2, 0xf2);
++
++- real0 = _mm_add_ps(xmm4, real0);
++- real1 = _mm_add_ps(xmm5, real1);
++- im0 = _mm_add_ps(xmm6, im0);
++- im1 = _mm_add_ps(xmm7, im1);
++- }
+++ real0 = _mm_add_ps(xmm4, real0);
+++ real1 = _mm_add_ps(xmm5, real1);
+++ im0 = _mm_add_ps(xmm6, im0);
+++ im1 = _mm_add_ps(xmm7, im1);
+++ }
++
++- real1 = _mm_xor_ps(real1, bit128_p(&neg)->float_vec);
+++ real1 = _mm_xor_ps(real1, bit128_p(&neg)->float_vec);
++
++- im0 = _mm_add_ps(im0, im1);
++- real0 = _mm_add_ps(real0, real1);
+++ im0 = _mm_add_ps(im0, im1);
+++ real0 = _mm_add_ps(real0, real1);
++
++- im0 = _mm_add_ps(im0, real0);
+++ im0 = _mm_add_ps(im0, real0);
++
++- _mm_storel_pi(p_result, im0);
+++ _mm_storel_pi(p_result, im0);
++
++- for(i = num_points-isodd; i < num_points; i++) {
++- *result += input[i] * taps[i];
++- }
+++ for (i = num_points - isodd; i < num_points; i++) {
+++ *result += input[i] * taps[i];
+++ }
++ }
++
++ #endif /*LV_HAVE_SSE4_1*/
++@@ -931,13 +982,17 @@ static inline void volk_32fc_x2_dot_prod_32fc_a_sse4_1(lv_32fc_t* result, const
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_32fc_x2_dot_prod_32fc_neon(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_neon(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++ unsigned int quarter_points = num_points / 4;
++ unsigned int number;
++
++- lv_32fc_t* a_ptr = (lv_32fc_t*) taps;
++- lv_32fc_t* b_ptr = (lv_32fc_t*) input;
+++ lv_32fc_t* a_ptr = (lv_32fc_t*)taps;
+++ lv_32fc_t* b_ptr = (lv_32fc_t*)input;
++ // for 2-lane vectors, 1st lane holds the real part,
++ // 2nd lane holds the imaginary part
++ float32x4x2_t a_val, b_val, c_val, accumulator;
++@@ -945,11 +1000,11 @@ static inline void volk_32fc_x2_dot_prod_32fc_neon(lv_32fc_t* result, const lv_3
++ accumulator.val[0] = vdupq_n_f32(0);
++ accumulator.val[1] = vdupq_n_f32(0);
++
++- for(number = 0; number < quarter_points; ++number) {
+++ for (number = 0; number < quarter_points; ++number) {
++ a_val = vld2q_f32((float*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
++ b_val = vld2q_f32((float*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
++- __VOLK_PREFETCH(a_ptr+8);
++- __VOLK_PREFETCH(b_ptr+8);
+++ __VOLK_PREFETCH(a_ptr + 8);
+++ __VOLK_PREFETCH(b_ptr + 8);
++
++ // multiply the real*real and imag*imag to get real result
++ // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
++@@ -977,22 +1032,25 @@ static inline void volk_32fc_x2_dot_prod_32fc_neon(lv_32fc_t* result, const lv_3
++ *result = accum_result[0] + accum_result[1] + accum_result[2] + accum_result[3];
++
++ // tail case
++- for(number = quarter_points*4; number < num_points; ++number) {
+++ for (number = quarter_points * 4; number < num_points; ++number) {
++ *result += (*a_ptr++) * (*b_ptr++);
++ }
++-
++ }
++ #endif /*LV_HAVE_NEON*/
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++-static inline void volk_32fc_x2_dot_prod_32fc_neon_opttests(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_neon_opttests(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++ unsigned int quarter_points = num_points / 4;
++ unsigned int number;
++
++- lv_32fc_t* a_ptr = (lv_32fc_t*) taps;
++- lv_32fc_t* b_ptr = (lv_32fc_t*) input;
+++ lv_32fc_t* a_ptr = (lv_32fc_t*)taps;
+++ lv_32fc_t* b_ptr = (lv_32fc_t*)input;
++ // for 2-lane vectors, 1st lane holds the real part,
++ // 2nd lane holds the imaginary part
++ float32x4x2_t a_val, b_val, accumulator;
++@@ -1000,11 +1058,11 @@ static inline void volk_32fc_x2_dot_prod_32fc_neon_opttests(lv_32fc_t* result, c
++ accumulator.val[0] = vdupq_n_f32(0);
++ accumulator.val[1] = vdupq_n_f32(0);
++
++- for(number = 0; number < quarter_points; ++number) {
+++ for (number = 0; number < quarter_points; ++number) {
++ a_val = vld2q_f32((float*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
++ b_val = vld2q_f32((float*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
++- __VOLK_PREFETCH(a_ptr+8);
++- __VOLK_PREFETCH(b_ptr+8);
+++ __VOLK_PREFETCH(a_ptr + 8);
+++ __VOLK_PREFETCH(b_ptr + 8);
++
++ // do the first multiply
++ tmp_imag.val[1] = vmulq_f32(a_val.val[1], b_val.val[0]);
++@@ -1026,21 +1084,24 @@ static inline void volk_32fc_x2_dot_prod_32fc_neon_opttests(lv_32fc_t* result, c
++ *result = accum_result[0] + accum_result[1] + accum_result[2] + accum_result[3];
++
++ // tail case
++- for(number = quarter_points*4; number < num_points; ++number) {
+++ for (number = quarter_points * 4; number < num_points; ++number) {
++ *result += (*a_ptr++) * (*b_ptr++);
++ }
++-
++ }
++ #endif /*LV_HAVE_NEON*/
++
++ #ifdef LV_HAVE_NEON
++-static inline void volk_32fc_x2_dot_prod_32fc_neon_optfma(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_neon_optfma(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++ unsigned int quarter_points = num_points / 4;
++ unsigned int number;
++
++- lv_32fc_t* a_ptr = (lv_32fc_t*) taps;
++- lv_32fc_t* b_ptr = (lv_32fc_t*) input;
+++ lv_32fc_t* a_ptr = (lv_32fc_t*)taps;
+++ lv_32fc_t* b_ptr = (lv_32fc_t*)input;
++ // for 2-lane vectors, 1st lane holds the real part,
++ // 2nd lane holds the imaginary part
++ float32x4x2_t a_val, b_val, accumulator1, accumulator2;
++@@ -1049,11 +1110,11 @@ static inline void volk_32fc_x2_dot_prod_32fc_neon_optfma(lv_32fc_t* result, con
++ accumulator2.val[0] = vdupq_n_f32(0);
++ accumulator2.val[1] = vdupq_n_f32(0);
++
++- for(number = 0; number < quarter_points; ++number) {
+++ for (number = 0; number < quarter_points; ++number) {
++ a_val = vld2q_f32((float*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
++ b_val = vld2q_f32((float*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
++- __VOLK_PREFETCH(a_ptr+8);
++- __VOLK_PREFETCH(b_ptr+8);
+++ __VOLK_PREFETCH(a_ptr + 8);
+++ __VOLK_PREFETCH(b_ptr + 8);
++
++ // use 2 accumulators to remove inter-instruction data dependencies
++ accumulator1.val[0] = vmlaq_f32(accumulator1.val[0], a_val.val[0], b_val.val[0]);
++@@ -1071,22 +1132,26 @@ static inline void volk_32fc_x2_dot_prod_32fc_neon_optfma(lv_32fc_t* result, con
++ *result = accum_result[0] + accum_result[1] + accum_result[2] + accum_result[3];
++
++ // tail case
++- for(number = quarter_points*4; number < num_points; ++number) {
+++ for (number = quarter_points * 4; number < num_points; ++number) {
++ *result += (*a_ptr++) * (*b_ptr++);
++ }
++-
++ }
++ #endif /*LV_HAVE_NEON*/
++
++ #ifdef LV_HAVE_NEON
++-static inline void volk_32fc_x2_dot_prod_32fc_neon_optfmaunroll(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
++-// NOTE: GCC does a poor job with this kernel, but the equivalent ASM code is very fast
+++static inline void volk_32fc_x2_dot_prod_32fc_neon_optfmaunroll(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
+++ // NOTE: GCC does a poor job with this kernel, but the equivalent ASM code is very
+++ // fast
++
++ unsigned int quarter_points = num_points / 8;
++ unsigned int number;
++
++- lv_32fc_t* a_ptr = (lv_32fc_t*) taps;
++- lv_32fc_t* b_ptr = (lv_32fc_t*) input;
+++ lv_32fc_t* a_ptr = (lv_32fc_t*)taps;
+++ lv_32fc_t* b_ptr = (lv_32fc_t*)input;
++ // for 2-lane vectors, 1st lane holds the real part,
++ // 2nd lane holds the imaginary part
++ float32x4x4_t a_val, b_val, accumulator1, accumulator2;
++@@ -1101,11 +1166,11 @@ static inline void volk_32fc_x2_dot_prod_32fc_neon_optfmaunroll(lv_32fc_t* resul
++ accumulator2.val[3] = vdupq_n_f32(0);
++
++ // 8 input regs, 8 accumulators -> 16/16 neon regs are used
++- for(number = 0; number < quarter_points; ++number) {
+++ for (number = 0; number < quarter_points; ++number) {
++ a_val = vld4q_f32((float*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
++ b_val = vld4q_f32((float*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
++- __VOLK_PREFETCH(a_ptr+8);
++- __VOLK_PREFETCH(b_ptr+8);
+++ __VOLK_PREFETCH(a_ptr + 8);
+++ __VOLK_PREFETCH(b_ptr + 8);
++
++ // use 2 accumulators to remove inter-instruction data dependencies
++ accumulator1.val[0] = vmlaq_f32(accumulator1.val[0], a_val.val[0], b_val.val[0]);
++@@ -1136,10 +1201,9 @@ static inline void volk_32fc_x2_dot_prod_32fc_neon_optfmaunroll(lv_32fc_t* resul
++ *result = accum_result[0] + accum_result[1] + accum_result[2] + accum_result[3];
++
++ // tail case
++- for(number = quarter_points*8; number < num_points; ++number) {
+++ for (number = quarter_points * 8; number < num_points; ++number) {
++ *result += (*a_ptr++) * (*b_ptr++);
++ }
++-
++ }
++ #endif /*LV_HAVE_NEON*/
++
++@@ -1148,56 +1212,64 @@ static inline void volk_32fc_x2_dot_prod_32fc_neon_optfmaunroll(lv_32fc_t* resul
++
++ #include <immintrin.h>
++
++-static inline void volk_32fc_x2_dot_prod_32fc_a_avx(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_a_avx(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- unsigned int isodd = num_points & 3;
++- unsigned int i = 0;
++- lv_32fc_t dotProduct;
++- memset(&dotProduct, 0x0, 2*sizeof(float));
+++ unsigned int isodd = num_points & 3;
+++ unsigned int i = 0;
+++ lv_32fc_t dotProduct;
+++ memset(&dotProduct, 0x0, 2 * sizeof(float));
++
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- __m256 x, y, yl, yh, z, tmp1, tmp2, dotProdVal;
+++ __m256 x, y, yl, yh, z, tmp1, tmp2, dotProdVal;
++
++- const lv_32fc_t* a = input;
++- const lv_32fc_t* b = taps;
+++ const lv_32fc_t* a = input;
+++ const lv_32fc_t* b = taps;
++
++- dotProdVal = _mm256_setzero_ps();
+++ dotProdVal = _mm256_setzero_ps();
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- x = _mm256_load_ps((float*)a); // Load a,b,e,f as ar,ai,br,bi,er,ei,fr,fi
++- y = _mm256_load_ps((float*)b); // Load c,d,g,h as cr,ci,dr,di,gr,gi,hr,hi
+++ x = _mm256_load_ps((float*)a); // Load a,b,e,f as ar,ai,br,bi,er,ei,fr,fi
+++ y = _mm256_load_ps((float*)b); // Load c,d,g,h as cr,ci,dr,di,gr,gi,hr,hi
++
++- yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr,gr,gr,hr,hr
++- yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di,gi,gi,hi,hi
+++ yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr,gr,gr,hr,hr
+++ yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di,gi,gi,hi,hi
++
++- tmp1 = _mm256_mul_ps(x,yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr ...
+++ tmp1 = _mm256_mul_ps(x, yl); // tmp1 = ar*cr,ai*cr,br*dr,bi*dr ...
++
++- x = _mm256_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br,ei,er,fi,fr
+++ x = _mm256_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br,ei,er,fi,fr
++
++- tmp2 = _mm256_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di ...
+++ tmp2 = _mm256_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di ...
++
++- z = _mm256_addsub_ps(tmp1,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ z = _mm256_addsub_ps(tmp1,
+++ tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- dotProdVal = _mm256_add_ps(dotProdVal, z); // Add the complex multiplication results together
+++ dotProdVal = _mm256_add_ps(dotProdVal,
+++ z); // Add the complex multiplication results together
++
++- a += 4;
++- b += 4;
++- }
+++ a += 4;
+++ b += 4;
+++ }
++
++- __VOLK_ATTR_ALIGNED(32) lv_32fc_t dotProductVector[4];
+++ __VOLK_ATTR_ALIGNED(32) lv_32fc_t dotProductVector[4];
++
++- _mm256_store_ps((float*)dotProductVector,dotProdVal); // Store the results back into the dot product vector
+++ _mm256_store_ps((float*)dotProductVector,
+++ dotProdVal); // Store the results back into the dot product vector
++
++- dotProduct += ( dotProductVector[0] + dotProductVector[1] + dotProductVector[2] + dotProductVector[3]);
+++ dotProduct += (dotProductVector[0] + dotProductVector[1] + dotProductVector[2] +
+++ dotProductVector[3]);
++
++- for(i = num_points-isodd; i < num_points; i++) {
++- dotProduct += input[i] * taps[i];
++- }
+++ for (i = num_points - isodd; i < num_points; i++) {
+++ dotProduct += input[i] * taps[i];
+++ }
++
++- *result = dotProduct;
+++ *result = dotProduct;
++ }
++
++ #endif /*LV_HAVE_AVX*/
++@@ -1205,56 +1277,64 @@ static inline void volk_32fc_x2_dot_prod_32fc_a_avx(lv_32fc_t* result, const lv_
++ #if LV_HAVE_AVX && LV_HAVE_FMA
++ #include <immintrin.h>
++
++-static inline void volk_32fc_x2_dot_prod_32fc_a_avx_fma(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
+++static inline void volk_32fc_x2_dot_prod_32fc_a_avx_fma(lv_32fc_t* result,
+++ const lv_32fc_t* input,
+++ const lv_32fc_t* taps,
+++ unsigned int num_points)
+++{
++
++- unsigned int isodd = num_points & 3;
++- unsigned int i = 0;
++- lv_32fc_t dotProduct;
++- memset(&dotProduct, 0x0, 2*sizeof(float));
+++ unsigned int isodd = num_points & 3;
+++ unsigned int i = 0;
+++ lv_32fc_t dotProduct;
+++ memset(&dotProduct, 0x0, 2 * sizeof(float));
++
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- __m256 x, y, yl, yh, z, tmp1, tmp2, dotProdVal;
+++ __m256 x, y, yl, yh, z, tmp1, tmp2, dotProdVal;
++
++- const lv_32fc_t* a = input;
++- const lv_32fc_t* b = taps;
+++ const lv_32fc_t* a = input;
+++ const lv_32fc_t* b = taps;
++
++- dotProdVal = _mm256_setzero_ps();
+++ dotProdVal = _mm256_setzero_ps();
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- x = _mm256_load_ps((float*)a); // Load a,b,e,f as ar,ai,br,bi,er,ei,fr,fi
++- y = _mm256_load_ps((float*)b); // Load c,d,g,h as cr,ci,dr,di,gr,gi,hr,hi
+++ x = _mm256_load_ps((float*)a); // Load a,b,e,f as ar,ai,br,bi,er,ei,fr,fi
+++ y = _mm256_load_ps((float*)b); // Load c,d,g,h as cr,ci,dr,di,gr,gi,hr,hi
++
++- yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr,gr,gr,hr,hr
++- yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di,gi,gi,hi,hi
+++ yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr,gr,gr,hr,hr
+++ yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di,gi,gi,hi,hi
++
++- tmp1 = x;
+++ tmp1 = x;
++
++- x = _mm256_shuffle_ps(x,x,0xB1); // Re-arrange x to be ai,ar,bi,br,ei,er,fi,fr
+++ x = _mm256_shuffle_ps(x, x, 0xB1); // Re-arrange x to be ai,ar,bi,br,ei,er,fi,fr
++
++- tmp2 = _mm256_mul_ps(x,yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di ...
+++ tmp2 = _mm256_mul_ps(x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di ...
++
++- z = _mm256_fmaddsub_ps(tmp1, yl,tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ z = _mm256_fmaddsub_ps(
+++ tmp1, yl, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- dotProdVal = _mm256_add_ps(dotProdVal, z); // Add the complex multiplication results together
+++ dotProdVal = _mm256_add_ps(dotProdVal,
+++ z); // Add the complex multiplication results together
++
++- a += 4;
++- b += 4;
++- }
+++ a += 4;
+++ b += 4;
+++ }
++
++- __VOLK_ATTR_ALIGNED(32) lv_32fc_t dotProductVector[4];
+++ __VOLK_ATTR_ALIGNED(32) lv_32fc_t dotProductVector[4];
++
++- _mm256_store_ps((float*)dotProductVector,dotProdVal); // Store the results back into the dot product vector
+++ _mm256_store_ps((float*)dotProductVector,
+++ dotProdVal); // Store the results back into the dot product vector
++
++- dotProduct += ( dotProductVector[0] + dotProductVector[1] + dotProductVector[2] + dotProductVector[3]);
+++ dotProduct += (dotProductVector[0] + dotProductVector[1] + dotProductVector[2] +
+++ dotProductVector[3]);
++
++- for(i = num_points-isodd; i < num_points; i++) {
++- dotProduct += input[i] * taps[i];
++- }
+++ for (i = num_points - isodd; i < num_points; i++) {
+++ dotProduct += input[i] * taps[i];
+++ }
++
++- *result = dotProduct;
+++ *result = dotProduct;
++ }
++
++ #endif /*LV_HAVE_AVX && LV_HAVE_FMA*/
++diff --git a/kernels/volk/volk_32fc_x2_multiply_32fc.h b/kernels/volk/volk_32fc_x2_multiply_32fc.h
++index 6bf428b..6cb6907 100644
++--- a/kernels/volk/volk_32fc_x2_multiply_32fc.h
+++++ b/kernels/volk/volk_32fc_x2_multiply_32fc.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_x2_multiply_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points);
++- * \endcode
+++ * void volk_32fc_x2_multiply_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const
+++ * lv_32fc_t* bVector, unsigned int num_points); \endcode
++ *
++ * \b Inputs
++ * \li aVector: The first input vector of complex floats.
++@@ -70,55 +70,62 @@
++ #ifndef INCLUDED_volk_32fc_x2_multiply_32fc_u_H
++ #define INCLUDED_volk_32fc_x2_multiply_32fc_u_H
++
+++#include <float.h>
++ #include <inttypes.h>
++ #include <stdio.h>
++ #include <volk/volk_complex.h>
++-#include <float.h>
++
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++ #include <immintrin.h>
++ /*!
++- \brief Multiplies the two input complex vectors and stores their results in the third vector
++- \param cVector The vector where the results will be stored
++- \param aVector One of the vectors to be multiplied
++- \param bVector One of the vectors to be multiplied
++- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector
+++ \brief Multiplies the two input complex vectors and stores their results in the third
+++ vector \param cVector The vector where the results will be stored \param aVector One of
+++ the vectors to be multiplied \param bVector One of the vectors to be multiplied \param
+++ num_points The number of complex values in aVector and bVector to be multiplied together
+++ and stored into cVector
++ */
++-static inline void volk_32fc_x2_multiply_32fc_u_avx2_fma(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++static inline void volk_32fc_x2_multiply_32fc_u_avx2_fma(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
++- const lv_32fc_t* b = bVector;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
+++ const lv_32fc_t* b = bVector;
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- const __m256 x = _mm256_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
++- const __m256 y = _mm256_loadu_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di
+++ const __m256 x =
+++ _mm256_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ const __m256 y =
+++ _mm256_loadu_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di
++
++- const __m256 yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr
++- const __m256 yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di
+++ const __m256 yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr
+++ const __m256 yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di
++
++- const __m256 tmp2x = _mm256_permute_ps(x,0xB1); // Re-arrange x to be ai,ar,bi,br
+++ const __m256 tmp2x = _mm256_permute_ps(x, 0xB1); // Re-arrange x to be ai,ar,bi,br
++
++- const __m256 tmp2 = _mm256_mul_ps(tmp2x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+++ const __m256 tmp2 = _mm256_mul_ps(tmp2x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
++
++- const __m256 z = _mm256_fmaddsub_ps(x, yl, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ const __m256 z = _mm256_fmaddsub_ps(
+++ x, yl, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- _mm256_storeu_ps((float*)c,z); // Store the results back into the C container
+++ _mm256_storeu_ps((float*)c, z); // Store the results back into the C container
++
++- a += 4;
++- b += 4;
++- c += 4;
++- }
+++ a += 4;
+++ b += 4;
+++ c += 4;
+++ }
++
++- _mm256_zeroupper();
+++ _mm256_zeroupper();
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *c++ = (*a++) * (*b++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *c++ = (*a++) * (*b++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA */
++
++@@ -127,34 +134,37 @@ static inline void volk_32fc_x2_multiply_32fc_u_avx2_fma(lv_32fc_t* cVector, con
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void
++-volk_32fc_x2_multiply_32fc_u_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_32fc_u_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- __m256 x, y, z;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
++- const lv_32fc_t* b = bVector;
++-
++- for(; number < quarterPoints; number++){
++- x = _mm256_loadu_ps((float*) a); // Load the ar + ai, br + bi ... as ar,ai,br,bi ...
++- y = _mm256_loadu_ps((float*) b); // Load the cr + ci, dr + di ... as cr,ci,dr,di ...
++- z = _mm256_complexmul_ps(x, y);
++- _mm256_storeu_ps((float*) c, z); // Store the results back into the C container
++-
++- a += 4;
++- b += 4;
++- c += 4;
++- }
++-
++- number = quarterPoints * 4;
++-
++- for(; number < num_points; number++){
++- *c++ = (*a++) * (*b++);
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ __m256 x, y, z;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
+++ const lv_32fc_t* b = bVector;
+++
+++ for (; number < quarterPoints; number++) {
+++ x = _mm256_loadu_ps(
+++ (float*)a); // Load the ar + ai, br + bi ... as ar,ai,br,bi ...
+++ y = _mm256_loadu_ps(
+++ (float*)b); // Load the cr + ci, dr + di ... as cr,ci,dr,di ...
+++ z = _mm256_complexmul_ps(x, y);
+++ _mm256_storeu_ps((float*)c, z); // Store the results back into the C container
+++
+++ a += 4;
+++ b += 4;
+++ c += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++
+++ for (; number < num_points; number++) {
+++ *c++ = (*a++) * (*b++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -163,50 +173,52 @@ volk_32fc_x2_multiply_32fc_u_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++ #include <pmmintrin.h>
++ #include <volk/volk_sse3_intrinsics.h>
++
++-static inline void
++-volk_32fc_x2_multiply_32fc_u_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_32fc_u_sse3(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int halfPoints = num_points / 2;
++-
++- __m128 x, y, z;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
++- const lv_32fc_t* b = bVector;
++-
++- for(; number < halfPoints; number++){
++- x = _mm_loadu_ps((float*) a); // Load the ar + ai, br + bi as ar,ai,br,bi
++- y = _mm_loadu_ps((float*) b); // Load the cr + ci, dr + di as cr,ci,dr,di
++- z = _mm_complexmul_ps(x, y);
++- _mm_storeu_ps((float*) c, z); // Store the results back into the C container
++-
++- a += 2;
++- b += 2;
++- c += 2;
++- }
++-
++- if((num_points % 2) != 0){
++- *c = (*a) * (*b);
++- }
+++ unsigned int number = 0;
+++ const unsigned int halfPoints = num_points / 2;
+++
+++ __m128 x, y, z;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
+++ const lv_32fc_t* b = bVector;
+++
+++ for (; number < halfPoints; number++) {
+++ x = _mm_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ y = _mm_loadu_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di
+++ z = _mm_complexmul_ps(x, y);
+++ _mm_storeu_ps((float*)c, z); // Store the results back into the C container
+++
+++ a += 2;
+++ b += 2;
+++ c += 2;
+++ }
+++
+++ if ((num_points % 2) != 0) {
+++ *c = (*a) * (*b);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_x2_multiply_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_32fc_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const lv_32fc_t* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const lv_32fc_t* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -215,55 +227,62 @@ volk_32fc_x2_multiply_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++ #ifndef INCLUDED_volk_32fc_x2_multiply_32fc_a_H
++ #define INCLUDED_volk_32fc_x2_multiply_32fc_a_H
++
+++#include <float.h>
++ #include <inttypes.h>
++ #include <stdio.h>
++ #include <volk/volk_complex.h>
++-#include <float.h>
++
++ #if LV_HAVE_AVX2 && LV_HAVE_FMA
++ #include <immintrin.h>
++ /*!
++- \brief Multiplies the two input complex vectors and stores their results in the third vector
++- \param cVector The vector where the results will be stored
++- \param aVector One of the vectors to be multiplied
++- \param bVector One of the vectors to be multiplied
++- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector
+++ \brief Multiplies the two input complex vectors and stores their results in the third
+++ vector \param cVector The vector where the results will be stored \param aVector One of
+++ the vectors to be multiplied \param bVector One of the vectors to be multiplied \param
+++ num_points The number of complex values in aVector and bVector to be multiplied together
+++ and stored into cVector
++ */
++-static inline void volk_32fc_x2_multiply_32fc_a_avx2_fma(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++static inline void volk_32fc_x2_multiply_32fc_a_avx2_fma(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
++- const lv_32fc_t* b = bVector;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
+++ const lv_32fc_t* b = bVector;
++
++- for(;number < quarterPoints; number++){
+++ for (; number < quarterPoints; number++) {
++
++- const __m256 x = _mm256_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
++- const __m256 y = _mm256_load_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di
+++ const __m256 x =
+++ _mm256_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ const __m256 y =
+++ _mm256_load_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di
++
++- const __m256 yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr
++- const __m256 yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di
+++ const __m256 yl = _mm256_moveldup_ps(y); // Load yl with cr,cr,dr,dr
+++ const __m256 yh = _mm256_movehdup_ps(y); // Load yh with ci,ci,di,di
++
++- const __m256 tmp2x = _mm256_permute_ps(x,0xB1); // Re-arrange x to be ai,ar,bi,br
+++ const __m256 tmp2x = _mm256_permute_ps(x, 0xB1); // Re-arrange x to be ai,ar,bi,br
++
++- const __m256 tmp2 = _mm256_mul_ps(tmp2x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
+++ const __m256 tmp2 = _mm256_mul_ps(tmp2x, yh); // tmp2 = ai*ci,ar*ci,bi*di,br*di
++
++- const __m256 z = _mm256_fmaddsub_ps(x, yl, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
+++ const __m256 z = _mm256_fmaddsub_ps(
+++ x, yl, tmp2); // ar*cr-ai*ci, ai*cr+ar*ci, br*dr-bi*di, bi*dr+br*di
++
++- _mm256_store_ps((float*)c,z); // Store the results back into the C container
+++ _mm256_store_ps((float*)c, z); // Store the results back into the C container
++
++- a += 4;
++- b += 4;
++- c += 4;
++- }
+++ a += 4;
+++ b += 4;
+++ c += 4;
+++ }
++
++- _mm256_zeroupper();
+++ _mm256_zeroupper();
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- *c++ = (*a++) * (*b++);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *c++ = (*a++) * (*b++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 && LV_HAVE_FMA */
++
++@@ -272,34 +291,35 @@ static inline void volk_32fc_x2_multiply_32fc_a_avx2_fma(lv_32fc_t* cVector, con
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void
++-volk_32fc_x2_multiply_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_32fc_a_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- __m256 x, y, z;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
++- const lv_32fc_t* b = bVector;
++-
++- for(; number < quarterPoints; number++){
++- x = _mm256_load_ps((float*) a); // Load the ar + ai, br + bi ... as ar,ai,br,bi ...
++- y = _mm256_load_ps((float*) b); // Load the cr + ci, dr + di ... as cr,ci,dr,di ...
++- z = _mm256_complexmul_ps(x, y);
++- _mm256_store_ps((float*) c, z); // Store the results back into the C container
++-
++- a += 4;
++- b += 4;
++- c += 4;
++- }
++-
++- number = quarterPoints * 4;
++-
++- for(; number < num_points; number++){
++- *c++ = (*a++) * (*b++);
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ __m256 x, y, z;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
+++ const lv_32fc_t* b = bVector;
+++
+++ for (; number < quarterPoints; number++) {
+++ x = _mm256_load_ps((float*)a); // Load the ar + ai, br + bi ... as ar,ai,br,bi ...
+++ y = _mm256_load_ps((float*)b); // Load the cr + ci, dr + di ... as cr,ci,dr,di ...
+++ z = _mm256_complexmul_ps(x, y);
+++ _mm256_store_ps((float*)c, z); // Store the results back into the C container
+++
+++ a += 4;
+++ b += 4;
+++ c += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++
+++ for (; number < num_points; number++) {
+++ *c++ = (*a++) * (*b++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -307,50 +327,52 @@ volk_32fc_x2_multiply_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++ #include <pmmintrin.h>
++ #include <volk/volk_sse3_intrinsics.h>
++
++-static inline void
++-volk_32fc_x2_multiply_32fc_a_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_32fc_a_sse3(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int halfPoints = num_points / 2;
++-
++- __m128 x, y, z;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
++- const lv_32fc_t* b = bVector;
++-
++- for(; number < halfPoints; number++){
++- x = _mm_load_ps((float*) a); // Load the ar + ai, br + bi as ar,ai,br,bi
++- y = _mm_load_ps((float*) b); // Load the cr + ci, dr + di as cr,ci,dr,di
++- z = _mm_complexmul_ps(x, y);
++- _mm_store_ps((float*) c, z); // Store the results back into the C container
++-
++- a += 2;
++- b += 2;
++- c += 2;
++- }
++-
++- if((num_points % 2) != 0){
++- *c = (*a) * (*b);
++- }
+++ unsigned int number = 0;
+++ const unsigned int halfPoints = num_points / 2;
+++
+++ __m128 x, y, z;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
+++ const lv_32fc_t* b = bVector;
+++
+++ for (; number < halfPoints; number++) {
+++ x = _mm_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ y = _mm_load_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di
+++ z = _mm_complexmul_ps(x, y);
+++ _mm_store_ps((float*)c, z); // Store the results back into the C container
+++
+++ a += 2;
+++ b += 2;
+++ c += 2;
+++ }
+++
+++ if ((num_points % 2) != 0) {
+++ *c = (*a) * (*b);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_x2_multiply_32fc_a_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_32fc_a_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const lv_32fc_t* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const lv_32fc_t* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -358,113 +380,118 @@ volk_32fc_x2_multiply_32fc_a_generic(lv_32fc_t* cVector, const lv_32fc_t* aVecto
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32fc_x2_multiply_32fc_neon(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_32fc_neon(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t *a_ptr = (lv_32fc_t*) aVector;
++- lv_32fc_t *b_ptr = (lv_32fc_t*) bVector;
++- unsigned int quarter_points = num_points / 4;
++- float32x4x2_t a_val, b_val, c_val;
++- float32x4x2_t tmp_real, tmp_imag;
++- unsigned int number = 0;
++-
++- for(number = 0; number < quarter_points; ++number) {
++- a_val = vld2q_f32((float*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
++- b_val = vld2q_f32((float*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
++- __VOLK_PREFETCH(a_ptr+4);
++- __VOLK_PREFETCH(b_ptr+4);
++-
++- // multiply the real*real and imag*imag to get real result
++- // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
++- tmp_real.val[0] = vmulq_f32(a_val.val[0], b_val.val[0]);
++- // a0i*b0i|a1i*b1i|a2i*b2i|a3i*b3i
++- tmp_real.val[1] = vmulq_f32(a_val.val[1], b_val.val[1]);
++-
++- // Multiply cross terms to get the imaginary result
++- // a0r*b0i|a1r*b1i|a2r*b2i|a3r*b3i
++- tmp_imag.val[0] = vmulq_f32(a_val.val[0], b_val.val[1]);
++- // a0i*b0r|a1i*b1r|a2i*b2r|a3i*b3r
++- tmp_imag.val[1] = vmulq_f32(a_val.val[1], b_val.val[0]);
++-
++- // store the results
++- c_val.val[0] = vsubq_f32(tmp_real.val[0], tmp_real.val[1]);
++- c_val.val[1] = vaddq_f32(tmp_imag.val[0], tmp_imag.val[1]);
++- vst2q_f32((float*)cVector, c_val);
++-
++- a_ptr += 4;
++- b_ptr += 4;
++- cVector += 4;
++- }
++-
++- for(number = quarter_points*4; number < num_points; number++){
++- *cVector++ = (*a_ptr++) * (*b_ptr++);
++- }
+++ lv_32fc_t* a_ptr = (lv_32fc_t*)aVector;
+++ lv_32fc_t* b_ptr = (lv_32fc_t*)bVector;
+++ unsigned int quarter_points = num_points / 4;
+++ float32x4x2_t a_val, b_val, c_val;
+++ float32x4x2_t tmp_real, tmp_imag;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < quarter_points; ++number) {
+++ a_val = vld2q_f32((float*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
+++ b_val = vld2q_f32((float*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
+++ __VOLK_PREFETCH(a_ptr + 4);
+++ __VOLK_PREFETCH(b_ptr + 4);
+++
+++ // multiply the real*real and imag*imag to get real result
+++ // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
+++ tmp_real.val[0] = vmulq_f32(a_val.val[0], b_val.val[0]);
+++ // a0i*b0i|a1i*b1i|a2i*b2i|a3i*b3i
+++ tmp_real.val[1] = vmulq_f32(a_val.val[1], b_val.val[1]);
+++
+++ // Multiply cross terms to get the imaginary result
+++ // a0r*b0i|a1r*b1i|a2r*b2i|a3r*b3i
+++ tmp_imag.val[0] = vmulq_f32(a_val.val[0], b_val.val[1]);
+++ // a0i*b0r|a1i*b1r|a2i*b2r|a3i*b3r
+++ tmp_imag.val[1] = vmulq_f32(a_val.val[1], b_val.val[0]);
+++
+++ // store the results
+++ c_val.val[0] = vsubq_f32(tmp_real.val[0], tmp_real.val[1]);
+++ c_val.val[1] = vaddq_f32(tmp_imag.val[0], tmp_imag.val[1]);
+++ vst2q_f32((float*)cVector, c_val);
+++
+++ a_ptr += 4;
+++ b_ptr += 4;
+++ cVector += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ *cVector++ = (*a_ptr++) * (*b_ptr++);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_NEON
++
++-static inline void
++-volk_32fc_x2_multiply_32fc_neon_opttests(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_32fc_neon_opttests(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t *a_ptr = (lv_32fc_t*) aVector;
++- lv_32fc_t *b_ptr = (lv_32fc_t*) bVector;
++- unsigned int quarter_points = num_points / 4;
++- float32x4x2_t a_val, b_val;
++- float32x4x2_t tmp_imag;
++- unsigned int number = 0;
++-
++- for(number = 0; number < quarter_points; ++number) {
++- a_val = vld2q_f32((float*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
++- b_val = vld2q_f32((float*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
++- __VOLK_PREFETCH(a_ptr+4);
++- __VOLK_PREFETCH(b_ptr+4);
++-
++- // do the first multiply
++- tmp_imag.val[1] = vmulq_f32(a_val.val[1], b_val.val[0]);
++- tmp_imag.val[0] = vmulq_f32(a_val.val[0], b_val.val[0]);
++-
++- // use multiply accumulate/subtract to get result
++- tmp_imag.val[1] = vmlaq_f32(tmp_imag.val[1], a_val.val[0], b_val.val[1]);
++- tmp_imag.val[0] = vmlsq_f32(tmp_imag.val[0], a_val.val[1], b_val.val[1]);
++-
++- // store
++- vst2q_f32((float*)cVector, tmp_imag);
++- // increment pointers
++- a_ptr += 4;
++- b_ptr += 4;
++- cVector += 4;
++- }
++-
++- for(number = quarter_points*4; number < num_points; number++){
++- *cVector++ = (*a_ptr++) * (*b_ptr++);
++- }
+++ lv_32fc_t* a_ptr = (lv_32fc_t*)aVector;
+++ lv_32fc_t* b_ptr = (lv_32fc_t*)bVector;
+++ unsigned int quarter_points = num_points / 4;
+++ float32x4x2_t a_val, b_val;
+++ float32x4x2_t tmp_imag;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < quarter_points; ++number) {
+++ a_val = vld2q_f32((float*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
+++ b_val = vld2q_f32((float*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
+++ __VOLK_PREFETCH(a_ptr + 4);
+++ __VOLK_PREFETCH(b_ptr + 4);
+++
+++ // do the first multiply
+++ tmp_imag.val[1] = vmulq_f32(a_val.val[1], b_val.val[0]);
+++ tmp_imag.val[0] = vmulq_f32(a_val.val[0], b_val.val[0]);
+++
+++ // use multiply accumulate/subtract to get result
+++ tmp_imag.val[1] = vmlaq_f32(tmp_imag.val[1], a_val.val[0], b_val.val[1]);
+++ tmp_imag.val[0] = vmlsq_f32(tmp_imag.val[0], a_val.val[1], b_val.val[1]);
+++
+++ // store
+++ vst2q_f32((float*)cVector, tmp_imag);
+++ // increment pointers
+++ a_ptr += 4;
+++ b_ptr += 4;
+++ cVector += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ *cVector++ = (*a_ptr++) * (*b_ptr++);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_NEONV7
++
++-extern void
++-volk_32fc_x2_multiply_32fc_a_neonasm(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points);
+++extern void volk_32fc_x2_multiply_32fc_a_neonasm(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points);
++ #endif /* LV_HAVE_NEONV7 */
++
++
++ #ifdef LV_HAVE_ORC
++
++-extern void
++-volk_32fc_x2_multiply_32fc_a_orc_impl(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points);
+++extern void volk_32fc_x2_multiply_32fc_a_orc_impl(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points);
++
++-static inline void
++-volk_32fc_x2_multiply_32fc_u_orc(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_32fc_u_orc(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- volk_32fc_x2_multiply_32fc_a_orc_impl(cVector, aVector, bVector, num_points);
+++ volk_32fc_x2_multiply_32fc_a_orc_impl(cVector, aVector, bVector, num_points);
++ }
++
++ #endif /* LV_HAVE_ORC */
++diff --git a/kernels/volk/volk_32fc_x2_multiply_conjugate_32fc.h b/kernels/volk/volk_32fc_x2_multiply_conjugate_32fc.h
++index 1b1a8b3..4f834c2 100644
++--- a/kernels/volk/volk_32fc_x2_multiply_conjugate_32fc.h
+++++ b/kernels/volk/volk_32fc_x2_multiply_conjugate_32fc.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_x2_multiply_conjugate_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points);
++- * \endcode
+++ * void volk_32fc_x2_multiply_conjugate_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector,
+++ * const lv_32fc_t* bVector, unsigned int num_points); \endcode
++ *
++ * \b Inputs
++ * \li aVector: The first input vector of complex floats.
++@@ -71,43 +71,46 @@
++ #ifndef INCLUDED_volk_32fc_x2_multiply_conjugate_32fc_u_H
++ #define INCLUDED_volk_32fc_x2_multiply_conjugate_32fc_u_H
++
+++#include <float.h>
++ #include <inttypes.h>
++ #include <stdio.h>
++ #include <volk/volk_complex.h>
++-#include <float.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void
++-volk_32fc_x2_multiply_conjugate_32fc_u_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_conjugate_32fc_u_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- __m256 x, y, z;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
++- const lv_32fc_t* b = bVector;
++-
++- for(; number < quarterPoints; number++){
++- x = _mm256_loadu_ps((float*) a); // Load the ar + ai, br + bi ... as ar,ai,br,bi ...
++- y = _mm256_loadu_ps((float*) b); // Load the cr + ci, dr + di ... as cr,ci,dr,di ...
++- z = _mm256_complexconjugatemul_ps(x, y);
++- _mm256_storeu_ps((float*) c, z); // Store the results back into the C container
++-
++- a += 4;
++- b += 4;
++- c += 4;
++- }
++-
++- number = quarterPoints * 4;
++-
++- for(; number < num_points; number++){
++- *c++ = (*a++) * lv_conj(*b++);
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ __m256 x, y, z;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
+++ const lv_32fc_t* b = bVector;
+++
+++ for (; number < quarterPoints; number++) {
+++ x = _mm256_loadu_ps(
+++ (float*)a); // Load the ar + ai, br + bi ... as ar,ai,br,bi ...
+++ y = _mm256_loadu_ps(
+++ (float*)b); // Load the cr + ci, dr + di ... as cr,ci,dr,di ...
+++ z = _mm256_complexconjugatemul_ps(x, y);
+++ _mm256_storeu_ps((float*)c, z); // Store the results back into the C container
+++
+++ a += 4;
+++ b += 4;
+++ c += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++
+++ for (; number < num_points; number++) {
+++ *c++ = (*a++) * lv_conj(*b++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -116,96 +119,98 @@ volk_32fc_x2_multiply_conjugate_32fc_u_avx(lv_32fc_t* cVector, const lv_32fc_t*
++ #include <pmmintrin.h>
++ #include <volk/volk_sse3_intrinsics.h>
++
++-static inline void
++-volk_32fc_x2_multiply_conjugate_32fc_u_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_conjugate_32fc_u_sse3(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int halfPoints = num_points / 2;
++-
++- __m128 x, y, z;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
++- const lv_32fc_t* b = bVector;
++-
++- for(; number < halfPoints; number++){
++- x = _mm_loadu_ps((float*) a); // Load the ar + ai, br + bi as ar,ai,br,bi
++- y = _mm_loadu_ps((float*) b); // Load the cr + ci, dr + di as cr,ci,dr,di
++- z = _mm_complexconjugatemul_ps(x, y);
++- _mm_storeu_ps((float*) c, z); // Store the results back into the C container
++-
++- a += 2;
++- b += 2;
++- c += 2;
++- }
++-
++- if((num_points % 2) != 0){
++- *c = (*a) * lv_conj(*b);
++- }
+++ unsigned int number = 0;
+++ const unsigned int halfPoints = num_points / 2;
+++
+++ __m128 x, y, z;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
+++ const lv_32fc_t* b = bVector;
+++
+++ for (; number < halfPoints; number++) {
+++ x = _mm_loadu_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ y = _mm_loadu_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di
+++ z = _mm_complexconjugatemul_ps(x, y);
+++ _mm_storeu_ps((float*)c, z); // Store the results back into the C container
+++
+++ a += 2;
+++ b += 2;
+++ c += 2;
+++ }
+++
+++ if ((num_points % 2) != 0) {
+++ *c = (*a) * lv_conj(*b);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32fc_x2_multiply_conjugate_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_conjugate_32fc_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const lv_32fc_t* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) * lv_conj(*bPtr++);
++- }
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const lv_32fc_t* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * lv_conj(*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++ #endif /* INCLUDED_volk_32fc_x2_multiply_conjugate_32fc_u_H */
++ #ifndef INCLUDED_volk_32fc_x2_multiply_conjugate_32fc_a_H
++ #define INCLUDED_volk_32fc_x2_multiply_conjugate_32fc_a_H
++
+++#include <float.h>
++ #include <inttypes.h>
++ #include <stdio.h>
++ #include <volk/volk_complex.h>
++-#include <float.h>
++
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void
++-volk_32fc_x2_multiply_conjugate_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_conjugate_32fc_a_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- __m256 x, y, z;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
++- const lv_32fc_t* b = bVector;
++-
++- for(; number < quarterPoints; number++){
++- x = _mm256_load_ps((float*) a); // Load the ar + ai, br + bi ... as ar,ai,br,bi ...
++- y = _mm256_load_ps((float*) b); // Load the cr + ci, dr + di ... as cr,ci,dr,di ...
++- z = _mm256_complexconjugatemul_ps(x, y);
++- _mm256_store_ps((float*) c, z); // Store the results back into the C container
++-
++- a += 4;
++- b += 4;
++- c += 4;
++- }
++-
++- number = quarterPoints * 4;
++-
++- for(; number < num_points; number++){
++- *c++ = (*a++) * lv_conj(*b++);
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ __m256 x, y, z;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
+++ const lv_32fc_t* b = bVector;
+++
+++ for (; number < quarterPoints; number++) {
+++ x = _mm256_load_ps((float*)a); // Load the ar + ai, br + bi ... as ar,ai,br,bi ...
+++ y = _mm256_load_ps((float*)b); // Load the cr + ci, dr + di ... as cr,ci,dr,di ...
+++ z = _mm256_complexconjugatemul_ps(x, y);
+++ _mm256_store_ps((float*)c, z); // Store the results back into the C container
+++
+++ a += 4;
+++ b += 4;
+++ c += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++
+++ for (; number < num_points; number++) {
+++ *c++ = (*a++) * lv_conj(*b++);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -214,32 +219,33 @@ volk_32fc_x2_multiply_conjugate_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t*
++ #include <pmmintrin.h>
++ #include <volk/volk_sse3_intrinsics.h>
++
++-static inline void
++-volk_32fc_x2_multiply_conjugate_32fc_a_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_conjugate_32fc_a_sse3(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int halfPoints = num_points / 2;
++-
++- __m128 x, y, z;
++- lv_32fc_t* c = cVector;
++- const lv_32fc_t* a = aVector;
++- const lv_32fc_t* b = bVector;
++-
++- for(; number < halfPoints; number++){
++- x = _mm_load_ps((float*) a); // Load the ar + ai, br + bi as ar,ai,br,bi
++- y = _mm_load_ps((float*) b); // Load the cr + ci, dr + di as cr,ci,dr,di
++- z = _mm_complexconjugatemul_ps(x, y);
++- _mm_store_ps((float*) c, z); // Store the results back into the C container
++-
++- a += 2;
++- b += 2;
++- c += 2;
++- }
++-
++- if((num_points % 2) != 0){
++- *c = (*a) * lv_conj(*b);
++- }
+++ unsigned int number = 0;
+++ const unsigned int halfPoints = num_points / 2;
+++
+++ __m128 x, y, z;
+++ lv_32fc_t* c = cVector;
+++ const lv_32fc_t* a = aVector;
+++ const lv_32fc_t* b = bVector;
+++
+++ for (; number < halfPoints; number++) {
+++ x = _mm_load_ps((float*)a); // Load the ar + ai, br + bi as ar,ai,br,bi
+++ y = _mm_load_ps((float*)b); // Load the cr + ci, dr + di as cr,ci,dr,di
+++ z = _mm_complexconjugatemul_ps(x, y);
+++ _mm_store_ps((float*)c, z); // Store the results back into the C container
+++
+++ a += 2;
+++ b += 2;
+++ c += 2;
+++ }
+++
+++ if ((num_points % 2) != 0) {
+++ *c = (*a) * lv_conj(*b);
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -247,49 +253,50 @@ volk_32fc_x2_multiply_conjugate_32fc_a_sse3(lv_32fc_t* cVector, const lv_32fc_t*
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32fc_x2_multiply_conjugate_32fc_neon(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++static inline void volk_32fc_x2_multiply_conjugate_32fc_neon(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t *a_ptr = (lv_32fc_t*) aVector;
++- lv_32fc_t *b_ptr = (lv_32fc_t*) bVector;
++- unsigned int quarter_points = num_points / 4;
++- float32x4x2_t a_val, b_val, c_val;
++- float32x4x2_t tmp_real, tmp_imag;
++- unsigned int number = 0;
++-
++- for(number = 0; number < quarter_points; ++number) {
++- a_val = vld2q_f32((float*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
++- b_val = vld2q_f32((float*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
++- b_val.val[1] = vnegq_f32(b_val.val[1]);
++- __VOLK_PREFETCH(a_ptr+4);
++- __VOLK_PREFETCH(b_ptr+4);
++-
++- // multiply the real*real and imag*imag to get real result
++- // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
++- tmp_real.val[0] = vmulq_f32(a_val.val[0], b_val.val[0]);
++- // a0i*b0i|a1i*b1i|a2i*b2i|a3i*b3i
++- tmp_real.val[1] = vmulq_f32(a_val.val[1], b_val.val[1]);
++-
++- // Multiply cross terms to get the imaginary result
+++ lv_32fc_t* a_ptr = (lv_32fc_t*)aVector;
+++ lv_32fc_t* b_ptr = (lv_32fc_t*)bVector;
+++ unsigned int quarter_points = num_points / 4;
+++ float32x4x2_t a_val, b_val, c_val;
+++ float32x4x2_t tmp_real, tmp_imag;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < quarter_points; ++number) {
+++ a_val = vld2q_f32((float*)a_ptr); // a0r|a1r|a2r|a3r || a0i|a1i|a2i|a3i
+++ b_val = vld2q_f32((float*)b_ptr); // b0r|b1r|b2r|b3r || b0i|b1i|b2i|b3i
+++ b_val.val[1] = vnegq_f32(b_val.val[1]);
+++ __VOLK_PREFETCH(a_ptr + 4);
+++ __VOLK_PREFETCH(b_ptr + 4);
+++
+++ // multiply the real*real and imag*imag to get real result
+++ // a0r*b0r|a1r*b1r|a2r*b2r|a3r*b3r
+++ tmp_real.val[0] = vmulq_f32(a_val.val[0], b_val.val[0]);
+++ // a0i*b0i|a1i*b1i|a2i*b2i|a3i*b3i
+++ tmp_real.val[1] = vmulq_f32(a_val.val[1], b_val.val[1]);
+++
+++ // Multiply cross terms to get the imaginary result
++ // a0r*b0i|a1r*b1i|a2r*b2i|a3r*b3i
++- tmp_imag.val[0] = vmulq_f32(a_val.val[0], b_val.val[1]);
++- // a0i*b0r|a1i*b1r|a2i*b2r|a3i*b3r
++- tmp_imag.val[1] = vmulq_f32(a_val.val[1], b_val.val[0]);
++-
++- // store the results
++- c_val.val[0] = vsubq_f32(tmp_real.val[0], tmp_real.val[1]);
++- c_val.val[1] = vaddq_f32(tmp_imag.val[0], tmp_imag.val[1]);
++- vst2q_f32((float*)cVector, c_val);
++-
++- a_ptr += 4;
++- b_ptr += 4;
++- cVector += 4;
+++ tmp_imag.val[0] = vmulq_f32(a_val.val[0], b_val.val[1]);
+++ // a0i*b0r|a1i*b1r|a2i*b2r|a3i*b3r
+++ tmp_imag.val[1] = vmulq_f32(a_val.val[1], b_val.val[0]);
+++
+++ // store the results
+++ c_val.val[0] = vsubq_f32(tmp_real.val[0], tmp_real.val[1]);
+++ c_val.val[1] = vaddq_f32(tmp_imag.val[0], tmp_imag.val[1]);
+++ vst2q_f32((float*)cVector, c_val);
+++
+++ a_ptr += 4;
+++ b_ptr += 4;
+++ cVector += 4;
++ }
++
++- for(number = quarter_points*4; number < num_points; number++){
++- *cVector++ = (*a_ptr++) * conj(*b_ptr++);
++- }
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ *cVector++ = (*a_ptr++) * conj(*b_ptr++);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++@@ -297,17 +304,19 @@ volk_32fc_x2_multiply_conjugate_32fc_neon(lv_32fc_t* cVector, const lv_32fc_t* a
++ #ifdef LV_HAVE_GENERIC
++
++ static inline void
++-volk_32fc_x2_multiply_conjugate_32fc_a_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector,
++- const lv_32fc_t* bVector, unsigned int num_points)
+++volk_32fc_x2_multiply_conjugate_32fc_a_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ unsigned int num_points)
++ {
++- lv_32fc_t* cPtr = cVector;
++- const lv_32fc_t* aPtr = aVector;
++- const lv_32fc_t* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) * lv_conj(*bPtr++);
++- }
+++ lv_32fc_t* cPtr = cVector;
+++ const lv_32fc_t* aPtr = aVector;
+++ const lv_32fc_t* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * lv_conj(*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++diff --git a/kernels/volk/volk_32fc_x2_s32f_square_dist_scalar_mult_32f.h b/kernels/volk/volk_32fc_x2_s32f_square_dist_scalar_mult_32f.h
++index 1c65f23..1d10561 100644
++--- a/kernels/volk/volk_32fc_x2_s32f_square_dist_scalar_mult_32f.h
+++++ b/kernels/volk/volk_32fc_x2_s32f_square_dist_scalar_mult_32f.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_x2_s32f_square_dist_scalar_mult_32f(float* target, lv_32fc_t* src0, lv_32fc_t* points, float scalar, unsigned int num_points)
++- * \endcode
+++ * void volk_32fc_x2_s32f_square_dist_scalar_mult_32f(float* target, lv_32fc_t* src0,
+++ * lv_32fc_t* points, float scalar, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li src0: The complex input. Only the first point is used.
++@@ -79,103 +79,107 @@
++ #ifndef INCLUDED_volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a_H
++ #define INCLUDED_volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a_H
++
++-#include<volk/volk_complex.h>
+++#include <volk/volk_complex.h>
++
++
++-static inline void
++-calculate_scaled_distances(float* target, const lv_32fc_t symbol, const lv_32fc_t* points,
++- const float scalar, const unsigned int num_points)
+++static inline void calculate_scaled_distances(float* target,
+++ const lv_32fc_t symbol,
+++ const lv_32fc_t* points,
+++ const float scalar,
+++ const unsigned int num_points)
++ {
++- lv_32fc_t diff;
++- for(unsigned int i = 0; i < num_points; ++i) {
++- /*
++- * Calculate: |y - x|^2 * SNR_lin
++- * Compare C++: *target++ = scalar * std::norm(symbol - *constellation++);
++- */
++- diff = symbol - *points++;
++- *target++ = scalar * (lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff));
++- }
+++ lv_32fc_t diff;
+++ for (unsigned int i = 0; i < num_points; ++i) {
+++ /*
+++ * Calculate: |y - x|^2 * SNR_lin
+++ * Compare C++: *target++ = scalar * std::norm(symbol - *constellation++);
+++ */
+++ diff = symbol - *points++;
+++ *target++ =
+++ scalar * (lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff));
+++ }
++ }
++
++
++ #ifdef LV_HAVE_AVX2
++-#include<immintrin.h>
++-#include<volk/volk_avx2_intrinsics.h>
+++#include <immintrin.h>
+++#include <volk/volk_avx2_intrinsics.h>
++
++ static inline void
++-volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a_avx2(float* target, lv_32fc_t* src0,
++- lv_32fc_t* points, float scalar,
+++volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a_avx2(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ float scalar,
++ unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*8;
++- __m128 xmm9, xmm10;
++- __m256 xmm4, xmm6;
++- __m256 xmm_points0, xmm_points1, xmm_result;
+++ const unsigned int num_bytes = num_points * 8;
+++ __m128 xmm9, xmm10;
+++ __m256 xmm4, xmm6;
+++ __m256 xmm_points0, xmm_points1, xmm_result;
++
++- const unsigned int bound = num_bytes >> 6;
++-
++- // load complex value into all parts of the register.
++- const __m256 xmm_symbol = _mm256_castpd_ps(_mm256_broadcast_sd((const double*)src0));
++- const __m128 xmm128_symbol = _mm256_extractf128_ps(xmm_symbol, 1);
++-
++- // Load scalar into all 8 parts of the register
++- const __m256 xmm_scalar = _mm256_broadcast_ss(&scalar);
++- const __m128 xmm128_scalar = _mm256_extractf128_ps(xmm_scalar, 1);
+++ const unsigned int bound = num_bytes >> 6;
++
++- // Set permutation constant
++- const __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
++-
++- for(unsigned int i = 0; i < bound; ++i) {
++- xmm_points0 = _mm256_load_ps((float*)points);
++- xmm_points1 = _mm256_load_ps((float*)(points + 4));
++- points += 8;
++- __VOLK_PREFETCH(points);
+++ // load complex value into all parts of the register.
+++ const __m256 xmm_symbol = _mm256_castpd_ps(_mm256_broadcast_sd((const double*)src0));
+++ const __m128 xmm128_symbol = _mm256_extractf128_ps(xmm_symbol, 1);
++
++- xmm_result = _mm256_scaled_norm_dist_ps_avx2(xmm_symbol, xmm_symbol,
++- xmm_points0, xmm_points1,
++- xmm_scalar);
++-
++- _mm256_store_ps(target, xmm_result);
++- target += 8;
++- }
+++ // Load scalar into all 8 parts of the register
+++ const __m256 xmm_scalar = _mm256_broadcast_ss(&scalar);
+++ const __m128 xmm128_scalar = _mm256_extractf128_ps(xmm_scalar, 1);
++
++- if (num_bytes >> 5 & 1) {
++- xmm_points0 = _mm256_load_ps((float*)points);
+++ // Set permutation constant
+++ const __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
++
++- xmm4 = _mm256_sub_ps(xmm_symbol, xmm_points0);
+++ for (unsigned int i = 0; i < bound; ++i) {
+++ xmm_points0 = _mm256_load_ps((float*)points);
+++ xmm_points1 = _mm256_load_ps((float*)(points + 4));
+++ points += 8;
+++ __VOLK_PREFETCH(points);
++
++- points += 4;
+++ xmm_result = _mm256_scaled_norm_dist_ps_avx2(
+++ xmm_symbol, xmm_symbol, xmm_points0, xmm_points1, xmm_scalar);
++
++- xmm6 = _mm256_mul_ps(xmm4, xmm4);
+++ _mm256_store_ps(target, xmm_result);
+++ target += 8;
+++ }
++
++- xmm4 = _mm256_hadd_ps(xmm6, xmm6);
++- xmm4 = _mm256_permutevar8x32_ps(xmm4, idx);
+++ if (num_bytes >> 5 & 1) {
+++ xmm_points0 = _mm256_load_ps((float*)points);
++
++- xmm_result = _mm256_mul_ps(xmm4, xmm_scalar);
+++ xmm4 = _mm256_sub_ps(xmm_symbol, xmm_points0);
++
++- xmm9 = _mm256_extractf128_ps(xmm_result, 1);
++- _mm_store_ps(target,xmm9);
++- target += 4;
++- }
+++ points += 4;
++
++- if (num_bytes >> 4 & 1) {
++- xmm9 = _mm_load_ps((float*)points);
+++ xmm6 = _mm256_mul_ps(xmm4, xmm4);
++
++- xmm10 = _mm_sub_ps(xmm128_symbol, xmm9);
+++ xmm4 = _mm256_hadd_ps(xmm6, xmm6);
+++ xmm4 = _mm256_permutevar8x32_ps(xmm4, idx);
++
++- points += 2;
+++ xmm_result = _mm256_mul_ps(xmm4, xmm_scalar);
++
++- xmm9 = _mm_mul_ps(xmm10, xmm10);
+++ xmm9 = _mm256_extractf128_ps(xmm_result, 1);
+++ _mm_store_ps(target, xmm9);
+++ target += 4;
+++ }
++
++- xmm10 = _mm_hadd_ps(xmm9, xmm9);
+++ if (num_bytes >> 4 & 1) {
+++ xmm9 = _mm_load_ps((float*)points);
++
++- xmm10 = _mm_mul_ps(xmm10, xmm128_scalar);
+++ xmm10 = _mm_sub_ps(xmm128_symbol, xmm9);
++
++- _mm_storeh_pi((__m64*)target, xmm10);
++- target += 2;
++- }
+++ points += 2;
++
++- calculate_scaled_distances(target, src0[0], points, scalar, (num_bytes >> 3) & 1);
+++ xmm9 = _mm_mul_ps(xmm10, xmm10);
+++
+++ xmm10 = _mm_hadd_ps(xmm9, xmm9);
+++
+++ xmm10 = _mm_mul_ps(xmm10, xmm128_scalar);
+++
+++ _mm_storeh_pi((__m64*)target, xmm10);
+++ target += 2;
+++ }
+++
+++ calculate_scaled_distances(target, src0[0], points, scalar, (num_bytes >> 3) & 1);
++ }
++
++ #endif /*LV_HAVE_AVX2*/
++@@ -186,131 +190,139 @@ volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a_avx2(float* target, lv_32fc_t* s
++ #include <volk/volk_avx_intrinsics.h>
++
++ static inline void
++-volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a_avx(float *target, lv_32fc_t *src0,
++- lv_32fc_t *points, float scalar,
++- unsigned int num_points) {
++- const int eightsPoints = num_points / 8;
++- const int remainder = num_points - 8 * eightsPoints;
++-
++- __m256 xmm_points0, xmm_points1, xmm_result;
++-
++- // load complex value into all parts of the register.
++- const __m256 xmm_symbol = _mm256_castpd_ps(_mm256_broadcast_sd((const double*)src0));
++-
++- // Load scalar into all 8 parts of the register
++- const __m256 xmm_scalar = _mm256_broadcast_ss(&scalar);
++-
++- for(int i = 0; i < eightsPoints; ++i){
++- xmm_points0 = _mm256_load_ps((float*)points);
++- xmm_points1 = _mm256_load_ps((float*)(points + 4));
++- points += 8;
++-
++- xmm_result = _mm256_scaled_norm_dist_ps(xmm_symbol, xmm_symbol, xmm_points0,
++- xmm_points1, xmm_scalar);
++-
++- _mm256_store_ps(target, xmm_result);
++- target += 8;
++- }
++-
++- const lv_32fc_t symbol = *src0;
++- calculate_scaled_distances(target, symbol, points, scalar, remainder);
+++volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a_avx(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ float scalar,
+++ unsigned int num_points)
+++{
+++ const int eightsPoints = num_points / 8;
+++ const int remainder = num_points - 8 * eightsPoints;
+++
+++ __m256 xmm_points0, xmm_points1, xmm_result;
+++
+++ // load complex value into all parts of the register.
+++ const __m256 xmm_symbol = _mm256_castpd_ps(_mm256_broadcast_sd((const double*)src0));
+++
+++ // Load scalar into all 8 parts of the register
+++ const __m256 xmm_scalar = _mm256_broadcast_ss(&scalar);
+++
+++ for (int i = 0; i < eightsPoints; ++i) {
+++ xmm_points0 = _mm256_load_ps((float*)points);
+++ xmm_points1 = _mm256_load_ps((float*)(points + 4));
+++ points += 8;
+++
+++ xmm_result = _mm256_scaled_norm_dist_ps(
+++ xmm_symbol, xmm_symbol, xmm_points0, xmm_points1, xmm_scalar);
+++
+++ _mm256_store_ps(target, xmm_result);
+++ target += 8;
+++ }
+++
+++ const lv_32fc_t symbol = *src0;
+++ calculate_scaled_distances(target, symbol, points, scalar, remainder);
++ }
++
++ #endif /* LV_HAVE_AVX */
++
++
++ #ifdef LV_HAVE_SSE3
++-#include<pmmintrin.h>
++-#include<volk/volk_sse3_intrinsics.h>
+++#include <pmmintrin.h>
+++#include <volk/volk_sse3_intrinsics.h>
++
++ static inline void
++-volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a_sse3(float* target, lv_32fc_t* src0,
++- lv_32fc_t* points, float scalar,
+++volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a_sse3(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ float scalar,
++ unsigned int num_points)
++ {
++- __m128 xmm_points0, xmm_points1, xmm_result;
++-
++- /*
++- * First do 4 values in every loop iteration.
++- * There may be up to 3 values left.
++- * leftovers0 indicates if at least 2 more are available for SSE execution.
++- * leftovers1 indicates if there is a single element left.
++- */
++- const int quarterPoints = num_points / 4;
++- const int leftovers0 = (num_points / 2) - 2 * quarterPoints;
++- const int leftovers1 = num_points % 2;
++-
++- // load complex value into both parts of the register.
++- const __m128 xmm_symbol = _mm_castpd_ps(_mm_load1_pd((const double*)src0));
++-
++- // Load scalar into all 4 parts of the register
++- const __m128 xmm_scalar = _mm_load1_ps(&scalar);
++-
++- for(int i = 0; i < quarterPoints; ++i) {
++- xmm_points0 = _mm_load_ps((float*)points);
++- xmm_points1 = _mm_load_ps((float*)(points + 2));
++- points += 4;
++- __VOLK_PREFETCH(points);
++- // calculate distances
++- xmm_result = _mm_scaled_norm_dist_ps_sse3(xmm_symbol, xmm_symbol, xmm_points0,
++- xmm_points1, xmm_scalar);
++-
++- _mm_store_ps(target, xmm_result);
++- target += 4;
++- }
++-
++- for(int i = 0; i < leftovers0; ++i) {
++- xmm_points0 = _mm_load_ps((float*)points);
++- points += 2;
++-
++- xmm_points0 = _mm_sub_ps(xmm_symbol, xmm_points0);
++- xmm_points0 = _mm_mul_ps(xmm_points0, xmm_points0);
++- xmm_points0 = _mm_hadd_ps(xmm_points0, xmm_points0);
++- xmm_result = _mm_mul_ps(xmm_points0, xmm_scalar);
++-
++- _mm_storeh_pi((__m64*)target, xmm_result);
++- target += 2;
++- }
++-
++- calculate_scaled_distances(target, src0[0], points, scalar, leftovers1);
+++ __m128 xmm_points0, xmm_points1, xmm_result;
+++
+++ /*
+++ * First do 4 values in every loop iteration.
+++ * There may be up to 3 values left.
+++ * leftovers0 indicates if at least 2 more are available for SSE execution.
+++ * leftovers1 indicates if there is a single element left.
+++ */
+++ const int quarterPoints = num_points / 4;
+++ const int leftovers0 = (num_points / 2) - 2 * quarterPoints;
+++ const int leftovers1 = num_points % 2;
+++
+++ // load complex value into both parts of the register.
+++ const __m128 xmm_symbol = _mm_castpd_ps(_mm_load1_pd((const double*)src0));
+++
+++ // Load scalar into all 4 parts of the register
+++ const __m128 xmm_scalar = _mm_load1_ps(&scalar);
+++
+++ for (int i = 0; i < quarterPoints; ++i) {
+++ xmm_points0 = _mm_load_ps((float*)points);
+++ xmm_points1 = _mm_load_ps((float*)(points + 2));
+++ points += 4;
+++ __VOLK_PREFETCH(points);
+++ // calculate distances
+++ xmm_result = _mm_scaled_norm_dist_ps_sse3(
+++ xmm_symbol, xmm_symbol, xmm_points0, xmm_points1, xmm_scalar);
+++
+++ _mm_store_ps(target, xmm_result);
+++ target += 4;
+++ }
+++
+++ for (int i = 0; i < leftovers0; ++i) {
+++ xmm_points0 = _mm_load_ps((float*)points);
+++ points += 2;
+++
+++ xmm_points0 = _mm_sub_ps(xmm_symbol, xmm_points0);
+++ xmm_points0 = _mm_mul_ps(xmm_points0, xmm_points0);
+++ xmm_points0 = _mm_hadd_ps(xmm_points0, xmm_points0);
+++ xmm_result = _mm_mul_ps(xmm_points0, xmm_scalar);
+++
+++ _mm_storeh_pi((__m64*)target, xmm_result);
+++ target += 2;
+++ }
+++
+++ calculate_scaled_distances(target, src0[0], points, scalar, leftovers1);
++ }
++
++ #endif /*LV_HAVE_SSE3*/
++
++ #ifdef LV_HAVE_SSE
++-#include <xmmintrin.h>
++ #include <volk/volk_sse_intrinsics.h>
+++#include <xmmintrin.h>
++ static inline void
++-volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a_sse(float* target, lv_32fc_t* src0,
++- lv_32fc_t* points, float scalar,
+++volk_32fc_x2_s32f_square_dist_scalar_mult_32f_a_sse(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ float scalar,
++ unsigned int num_points)
++ {
++- const __m128 xmm_scalar = _mm_set1_ps(scalar);
++- const __m128 xmm_symbol = _mm_castpd_ps(_mm_load1_pd((const double*)src0));
++-
++- for (unsigned i = 0; i < num_points / 4; ++i) {
++- __m128 xmm_points0 = _mm_load_ps((float *) points);
++- __m128 xmm_points1 = _mm_load_ps((float *) (points + 2));
++- points += 4;
++- __m128 xmm_result = _mm_scaled_norm_dist_ps_sse(xmm_symbol, xmm_symbol,
++- xmm_points0, xmm_points1,
++- xmm_scalar);
++- _mm_store_ps((float *) target, xmm_result);
++- target += 4;
++- }
++-
++- calculate_scaled_distances(target, src0[0], points, scalar, num_points % 4);
+++ const __m128 xmm_scalar = _mm_set1_ps(scalar);
+++ const __m128 xmm_symbol = _mm_castpd_ps(_mm_load1_pd((const double*)src0));
+++
+++ for (unsigned i = 0; i < num_points / 4; ++i) {
+++ __m128 xmm_points0 = _mm_load_ps((float*)points);
+++ __m128 xmm_points1 = _mm_load_ps((float*)(points + 2));
+++ points += 4;
+++ __m128 xmm_result = _mm_scaled_norm_dist_ps_sse(
+++ xmm_symbol, xmm_symbol, xmm_points0, xmm_points1, xmm_scalar);
+++ _mm_store_ps((float*)target, xmm_result);
+++ target += 4;
+++ }
+++
+++ calculate_scaled_distances(target, src0[0], points, scalar, num_points % 4);
++ }
++ #endif // LV_HAVE_SSE
++
++ #ifdef LV_HAVE_GENERIC
++ static inline void
++-volk_32fc_x2_s32f_square_dist_scalar_mult_32f_generic(float* target, lv_32fc_t* src0,
++- lv_32fc_t* points, float scalar,
+++volk_32fc_x2_s32f_square_dist_scalar_mult_32f_generic(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ float scalar,
++ unsigned int num_points)
++ {
++- const lv_32fc_t symbol = *src0;
++- calculate_scaled_distances(target, symbol, points, scalar, num_points);
+++ const lv_32fc_t symbol = *src0;
+++ calculate_scaled_distances(target, symbol, points, scalar, num_points);
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -321,87 +333,88 @@ volk_32fc_x2_s32f_square_dist_scalar_mult_32f_generic(float* target, lv_32fc_t*
++ #ifndef INCLUDED_volk_32fc_x2_s32f_square_dist_scalar_mult_32f_u_H
++ #define INCLUDED_volk_32fc_x2_s32f_square_dist_scalar_mult_32f_u_H
++
++-#include<volk/volk_complex.h>
+++#include <volk/volk_complex.h>
++
++
++ #ifdef LV_HAVE_AVX2
++-#include<immintrin.h>
+++#include <immintrin.h>
++ #include <volk/volk_avx2_intrinsics.h>
++
++ static inline void
++-volk_32fc_x2_s32f_square_dist_scalar_mult_32f_u_avx2(float* target, lv_32fc_t* src0,
++- lv_32fc_t* points, float scalar,
+++volk_32fc_x2_s32f_square_dist_scalar_mult_32f_u_avx2(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ float scalar,
++ unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*8;
++- __m128 xmm9, xmm10;
++- __m256 xmm4, xmm6;
++- __m256 xmm_points0, xmm_points1, xmm_result;
+++ const unsigned int num_bytes = num_points * 8;
+++ __m128 xmm9, xmm10;
+++ __m256 xmm4, xmm6;
+++ __m256 xmm_points0, xmm_points1, xmm_result;
+++
+++ const unsigned int bound = num_bytes >> 6;
+++
+++ // load complex value into all parts of the register.
+++ const __m256 xmm_symbol = _mm256_castpd_ps(_mm256_broadcast_sd((const double*)src0));
+++ const __m128 xmm128_symbol = _mm256_extractf128_ps(xmm_symbol, 1);
+++
+++ // Load scalar into all 8 parts of the register
+++ const __m256 xmm_scalar = _mm256_broadcast_ss(&scalar);
+++ const __m128 xmm128_scalar = _mm256_extractf128_ps(xmm_scalar, 1);
++
++- const unsigned int bound = num_bytes >> 6;
++-
++- // load complex value into all parts of the register.
++- const __m256 xmm_symbol = _mm256_castpd_ps(_mm256_broadcast_sd((const double*)src0));
++- const __m128 xmm128_symbol = _mm256_extractf128_ps(xmm_symbol, 1);
++-
++- // Load scalar into all 8 parts of the register
++- const __m256 xmm_scalar = _mm256_broadcast_ss(&scalar);
++- const __m128 xmm128_scalar = _mm256_extractf128_ps(xmm_scalar, 1);
+++ // Set permutation constant
+++ const __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
++
++- // Set permutation constant
++- const __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
++-
++- for(unsigned int i = 0; i < bound; ++i) {
++- xmm_points0 = _mm256_loadu_ps((float*)points);
++- xmm_points1 = _mm256_loadu_ps((float*)(points + 4));
++- points += 8;
++- __VOLK_PREFETCH(points);
+++ for (unsigned int i = 0; i < bound; ++i) {
+++ xmm_points0 = _mm256_loadu_ps((float*)points);
+++ xmm_points1 = _mm256_loadu_ps((float*)(points + 4));
+++ points += 8;
+++ __VOLK_PREFETCH(points);
++
++- xmm_result = _mm256_scaled_norm_dist_ps_avx2(xmm_symbol, xmm_symbol,
++- xmm_points0, xmm_points1,
++- xmm_scalar);
++-
++- _mm256_storeu_ps(target, xmm_result);
++- target += 8;
++- }
+++ xmm_result = _mm256_scaled_norm_dist_ps_avx2(
+++ xmm_symbol, xmm_symbol, xmm_points0, xmm_points1, xmm_scalar);
++
++- if (num_bytes >> 5 & 1) {
++- xmm_points0 = _mm256_loadu_ps((float*)points);
+++ _mm256_storeu_ps(target, xmm_result);
+++ target += 8;
+++ }
++
++- xmm4 = _mm256_sub_ps(xmm_symbol, xmm_points0);
+++ if (num_bytes >> 5 & 1) {
+++ xmm_points0 = _mm256_loadu_ps((float*)points);
++
++- points += 4;
+++ xmm4 = _mm256_sub_ps(xmm_symbol, xmm_points0);
++
++- xmm6 = _mm256_mul_ps(xmm4, xmm4);
+++ points += 4;
++
++- xmm4 = _mm256_hadd_ps(xmm6, xmm6);
++- xmm4 = _mm256_permutevar8x32_ps(xmm4, idx);
+++ xmm6 = _mm256_mul_ps(xmm4, xmm4);
++
++- xmm_result = _mm256_mul_ps(xmm4, xmm_scalar);
+++ xmm4 = _mm256_hadd_ps(xmm6, xmm6);
+++ xmm4 = _mm256_permutevar8x32_ps(xmm4, idx);
++
++- xmm9 = _mm256_extractf128_ps(xmm_result, 1);
++- _mm_storeu_ps(target,xmm9);
++- target += 4;
++- }
+++ xmm_result = _mm256_mul_ps(xmm4, xmm_scalar);
++
++- if (num_bytes >> 4 & 1) {
++- xmm9 = _mm_loadu_ps((float*)points);
+++ xmm9 = _mm256_extractf128_ps(xmm_result, 1);
+++ _mm_storeu_ps(target, xmm9);
+++ target += 4;
+++ }
++
++- xmm10 = _mm_sub_ps(xmm128_symbol, xmm9);
+++ if (num_bytes >> 4 & 1) {
+++ xmm9 = _mm_loadu_ps((float*)points);
++
++- points += 2;
+++ xmm10 = _mm_sub_ps(xmm128_symbol, xmm9);
++
++- xmm9 = _mm_mul_ps(xmm10, xmm10);
+++ points += 2;
++
++- xmm10 = _mm_hadd_ps(xmm9, xmm9);
+++ xmm9 = _mm_mul_ps(xmm10, xmm10);
++
++- xmm10 = _mm_mul_ps(xmm10, xmm128_scalar);
+++ xmm10 = _mm_hadd_ps(xmm9, xmm9);
++
++- _mm_storeh_pi((__m64*)target, xmm10);
++- target += 2;
++- }
+++ xmm10 = _mm_mul_ps(xmm10, xmm128_scalar);
++
++- calculate_scaled_distances(target, src0[0], points, scalar, (num_bytes >> 3) & 1);
+++ _mm_storeh_pi((__m64*)target, xmm10);
+++ target += 2;
+++ }
+++
+++ calculate_scaled_distances(target, src0[0], points, scalar, (num_bytes >> 3) & 1);
++ }
++
++ #endif /*LV_HAVE_AVX2*/
++@@ -412,120 +425,126 @@ volk_32fc_x2_s32f_square_dist_scalar_mult_32f_u_avx2(float* target, lv_32fc_t* s
++ #include <volk/volk_avx_intrinsics.h>
++
++ static inline void
++-volk_32fc_x2_s32f_square_dist_scalar_mult_32f_u_avx(float *target, lv_32fc_t *src0,
++- lv_32fc_t *points, float scalar,
++- unsigned int num_points) {
++- const int eightsPoints = num_points / 8;
++- const int remainder = num_points - 8 * eightsPoints;
++-
++- __m256 xmm_points0, xmm_points1, xmm_result;
++-
++- // load complex value into all parts of the register.
++- const __m256 xmm_symbol = _mm256_castpd_ps(_mm256_broadcast_sd((const double*)src0));
++-
++- // Load scalar into all 8 parts of the register
++- const __m256 xmm_scalar = _mm256_broadcast_ss(&scalar);
++-
++- for(int i = 0; i < eightsPoints; ++i){
++- xmm_points0 = _mm256_loadu_ps((float*)points);
++- xmm_points1 = _mm256_loadu_ps((float*)(points + 4));
++- points += 8;
++-
++- xmm_result = _mm256_scaled_norm_dist_ps(xmm_symbol, xmm_symbol, xmm_points0,
++- xmm_points1, xmm_scalar);
++-
++- _mm256_storeu_ps(target, xmm_result);
++- target += 8;
++- }
++-
++- const lv_32fc_t symbol = *src0;
++- calculate_scaled_distances(target, symbol, points, scalar, remainder);
+++volk_32fc_x2_s32f_square_dist_scalar_mult_32f_u_avx(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ float scalar,
+++ unsigned int num_points)
+++{
+++ const int eightsPoints = num_points / 8;
+++ const int remainder = num_points - 8 * eightsPoints;
+++
+++ __m256 xmm_points0, xmm_points1, xmm_result;
+++
+++ // load complex value into all parts of the register.
+++ const __m256 xmm_symbol = _mm256_castpd_ps(_mm256_broadcast_sd((const double*)src0));
+++
+++ // Load scalar into all 8 parts of the register
+++ const __m256 xmm_scalar = _mm256_broadcast_ss(&scalar);
+++
+++ for (int i = 0; i < eightsPoints; ++i) {
+++ xmm_points0 = _mm256_loadu_ps((float*)points);
+++ xmm_points1 = _mm256_loadu_ps((float*)(points + 4));
+++ points += 8;
+++
+++ xmm_result = _mm256_scaled_norm_dist_ps(
+++ xmm_symbol, xmm_symbol, xmm_points0, xmm_points1, xmm_scalar);
+++
+++ _mm256_storeu_ps(target, xmm_result);
+++ target += 8;
+++ }
+++
+++ const lv_32fc_t symbol = *src0;
+++ calculate_scaled_distances(target, symbol, points, scalar, remainder);
++ }
++
++ #endif /* LV_HAVE_AVX */
++
++
++ #ifdef LV_HAVE_SSE3
++-#include<pmmintrin.h>
++-#include<volk/volk_sse3_intrinsics.h>
+++#include <pmmintrin.h>
+++#include <volk/volk_sse3_intrinsics.h>
++
++ static inline void
++-volk_32fc_x2_s32f_square_dist_scalar_mult_32f_u_sse3(float* target, lv_32fc_t* src0,
++- lv_32fc_t* points, float scalar,
+++volk_32fc_x2_s32f_square_dist_scalar_mult_32f_u_sse3(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ float scalar,
++ unsigned int num_points)
++ {
++- __m128 xmm_points0, xmm_points1, xmm_result;
++-
++- /*
++- * First do 4 values in every loop iteration.
++- * There may be up to 3 values left.
++- * leftovers0 indicates if at least 2 more are available for SSE execution.
++- * leftovers1 indicates if there is a single element left.
++- */
++- const int quarterPoints = num_points / 4;
++- const int leftovers0 = (num_points / 2) - 2 * quarterPoints;
++- const int leftovers1 = num_points % 2;
++-
++- // load complex value into both parts of the register.
++- const __m128 xmm_symbol = _mm_castpd_ps(_mm_load1_pd((const double*)src0));
++-
++- // Load scalar into all 4 parts of the register
++- const __m128 xmm_scalar = _mm_load1_ps(&scalar);
++-
++- for(int i = 0; i < quarterPoints; ++i) {
++- xmm_points0 = _mm_loadu_ps((float*)points);
++- xmm_points1 = _mm_loadu_ps((float*)(points + 2));
++- points += 4;
++- __VOLK_PREFETCH(points);
++- // calculate distances
++- xmm_result = _mm_scaled_norm_dist_ps_sse3(xmm_symbol, xmm_symbol, xmm_points0,
++- xmm_points1, xmm_scalar);
++-
++- _mm_storeu_ps(target, xmm_result);
++- target += 4;
++- }
++-
++- for(int i = 0; i < leftovers0; ++i) {
++- xmm_points0 = _mm_loadu_ps((float*)points);
++- points += 2;
++-
++- xmm_points0 = _mm_sub_ps(xmm_symbol, xmm_points0);
++- xmm_points0 = _mm_mul_ps(xmm_points0, xmm_points0);
++- xmm_points0 = _mm_hadd_ps(xmm_points0, xmm_points0);
++- xmm_result = _mm_mul_ps(xmm_points0, xmm_scalar);
++-
++- _mm_storeh_pi((__m64*)target, xmm_result);
++- target += 2;
++- }
++-
++- calculate_scaled_distances(target, src0[0], points, scalar, leftovers1);
+++ __m128 xmm_points0, xmm_points1, xmm_result;
+++
+++ /*
+++ * First do 4 values in every loop iteration.
+++ * There may be up to 3 values left.
+++ * leftovers0 indicates if at least 2 more are available for SSE execution.
+++ * leftovers1 indicates if there is a single element left.
+++ */
+++ const int quarterPoints = num_points / 4;
+++ const int leftovers0 = (num_points / 2) - 2 * quarterPoints;
+++ const int leftovers1 = num_points % 2;
+++
+++ // load complex value into both parts of the register.
+++ const __m128 xmm_symbol = _mm_castpd_ps(_mm_load1_pd((const double*)src0));
+++
+++ // Load scalar into all 4 parts of the register
+++ const __m128 xmm_scalar = _mm_load1_ps(&scalar);
+++
+++ for (int i = 0; i < quarterPoints; ++i) {
+++ xmm_points0 = _mm_loadu_ps((float*)points);
+++ xmm_points1 = _mm_loadu_ps((float*)(points + 2));
+++ points += 4;
+++ __VOLK_PREFETCH(points);
+++ // calculate distances
+++ xmm_result = _mm_scaled_norm_dist_ps_sse3(
+++ xmm_symbol, xmm_symbol, xmm_points0, xmm_points1, xmm_scalar);
+++
+++ _mm_storeu_ps(target, xmm_result);
+++ target += 4;
+++ }
+++
+++ for (int i = 0; i < leftovers0; ++i) {
+++ xmm_points0 = _mm_loadu_ps((float*)points);
+++ points += 2;
+++
+++ xmm_points0 = _mm_sub_ps(xmm_symbol, xmm_points0);
+++ xmm_points0 = _mm_mul_ps(xmm_points0, xmm_points0);
+++ xmm_points0 = _mm_hadd_ps(xmm_points0, xmm_points0);
+++ xmm_result = _mm_mul_ps(xmm_points0, xmm_scalar);
+++
+++ _mm_storeh_pi((__m64*)target, xmm_result);
+++ target += 2;
+++ }
+++
+++ calculate_scaled_distances(target, src0[0], points, scalar, leftovers1);
++ }
++
++ #endif /*LV_HAVE_SSE3*/
++
++ #ifdef LV_HAVE_SSE
++-#include <xmmintrin.h>
++ #include <volk/volk_sse_intrinsics.h>
+++#include <xmmintrin.h>
++ static inline void
++-volk_32fc_x2_s32f_square_dist_scalar_mult_32f_u_sse(float* target, lv_32fc_t* src0,
++- lv_32fc_t* points, float scalar,
+++volk_32fc_x2_s32f_square_dist_scalar_mult_32f_u_sse(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ float scalar,
++ unsigned int num_points)
++ {
++- const __m128 xmm_scalar = _mm_set1_ps(scalar);
++- const __m128 xmm_symbol = _mm_castpd_ps(_mm_load1_pd((const double*)src0));
++-
++- for (unsigned i = 0; i < num_points / 4; ++i) {
++- __m128 xmm_points0 = _mm_loadu_ps((float *) points);
++- __m128 xmm_points1 = _mm_loadu_ps((float *) (points + 2));
++- points += 4;
++- __m128 xmm_result = _mm_scaled_norm_dist_ps_sse(xmm_symbol, xmm_symbol,
++- xmm_points0, xmm_points1,
++- xmm_scalar);
++- _mm_storeu_ps((float *) target, xmm_result);
++- target += 4;
++- }
++-
++- calculate_scaled_distances(target, src0[0], points, scalar, num_points % 4);
+++ const __m128 xmm_scalar = _mm_set1_ps(scalar);
+++ const __m128 xmm_symbol = _mm_castpd_ps(_mm_load1_pd((const double*)src0));
+++
+++ for (unsigned i = 0; i < num_points / 4; ++i) {
+++ __m128 xmm_points0 = _mm_loadu_ps((float*)points);
+++ __m128 xmm_points1 = _mm_loadu_ps((float*)(points + 2));
+++ points += 4;
+++ __m128 xmm_result = _mm_scaled_norm_dist_ps_sse(
+++ xmm_symbol, xmm_symbol, xmm_points0, xmm_points1, xmm_scalar);
+++ _mm_storeu_ps((float*)target, xmm_result);
+++ target += 4;
+++ }
+++
+++ calculate_scaled_distances(target, src0[0], points, scalar, num_points % 4);
++ }
++ #endif // LV_HAVE_SSE
++
++diff --git a/kernels/volk/volk_32fc_x2_s32fc_multiply_conjugate_add_32fc.h b/kernels/volk/volk_32fc_x2_s32fc_multiply_conjugate_add_32fc.h
++index 6c7f4d3..1fb9b68 100644
++--- a/kernels/volk/volk_32fc_x2_s32fc_multiply_conjugate_add_32fc.h
+++++ b/kernels/volk/volk_32fc_x2_s32fc_multiply_conjugate_add_32fc.h
++@@ -32,14 +32,16 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, const lv_32fc_t scalar, unsigned int num_points);
++- * \endcode
+++ * void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc(lv_32fc_t* cVector, const
+++ * lv_32fc_t* aVector, const lv_32fc_t* bVector, const lv_32fc_t scalar, unsigned int
+++ * num_points); \endcode
++ *
++ * \b Inputs
++ * \li aVector: The input vector to be added.
++ * \li bVector: The input vector to be conjugate and multiplied.
++ * \li scalar: The complex scalar to multiply against conjugated bVector.
++- * \li num_points: The number of complex values in aVector and bVector to be conjugate, multiplied and stored into cVector.
+++ * \li num_points: The number of complex values in aVector and bVector to be conjugate,
+++ * multiplied and stored into cVector.
++ *
++ * \b Outputs
++ * \li cVector: The vector where the results will be stored.
++@@ -84,15 +86,21 @@
++ #ifndef INCLUDED_volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_H
++ #define INCLUDED_volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_H
++
+++#include <float.h>
++ #include <inttypes.h>
++ #include <stdio.h>
++ #include <volk/volk_complex.h>
++-#include <float.h>
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, const lv_32fc_t scalar, unsigned int num_points){
+++static inline void
+++volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_generic(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
++ const lv_32fc_t* aPtr = aVector;
++ const lv_32fc_t* bPtr = bVector;
++ lv_32fc_t* cPtr = cVector;
++@@ -123,14 +131,20 @@ static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_generic(lv_32f
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_u_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, const lv_32fc_t scalar, unsigned int num_points) {
+++static inline void
+++volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_u_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
++ unsigned int number = 0;
++ unsigned int i = 0;
++ const unsigned int quarterPoints = num_points / 4;
++ unsigned int isodd = num_points & 3;
++
++ __m256 x, y, s, z;
++- lv_32fc_t v_scalar[4] = {scalar, scalar, scalar, scalar};
+++ lv_32fc_t v_scalar[4] = { scalar, scalar, scalar, scalar };
++
++ const lv_32fc_t* a = aVector;
++ const lv_32fc_t* b = bVector;
++@@ -139,19 +153,19 @@ static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_u_avx(lv_32fc_
++ // Set up constant scalar vector
++ s = _mm256_loadu_ps((float*)v_scalar);
++
++- for(;number < quarterPoints; number++) {
+++ for (; number < quarterPoints; number++) {
++ x = _mm256_loadu_ps((float*)b);
++ y = _mm256_loadu_ps((float*)a);
++ z = _mm256_complexconjugatemul_ps(s, x);
++ z = _mm256_add_ps(y, z);
++- _mm256_storeu_ps((float*)c,z);
+++ _mm256_storeu_ps((float*)c, z);
++
++ a += 4;
++ b += 4;
++ c += 4;
++ }
++
++- for(i = num_points-isodd; i < num_points; i++) {
+++ for (i = num_points - isodd; i < num_points; i++) {
++ *c++ = (*a++) + lv_conj(*b++) * scalar;
++ }
++ }
++@@ -162,12 +176,18 @@ static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_u_avx(lv_32fc_
++ #include <pmmintrin.h>
++ #include <volk/volk_sse3_intrinsics.h>
++
++-static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_u_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, const lv_32fc_t scalar, unsigned int num_points) {
+++static inline void
+++volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_u_sse3(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
++ unsigned int number = 0;
++ const unsigned int halfPoints = num_points / 2;
++
++ __m128 x, y, s, z;
++- lv_32fc_t v_scalar[2] = {scalar, scalar};
+++ lv_32fc_t v_scalar[2] = { scalar, scalar };
++
++ const lv_32fc_t* a = aVector;
++ const lv_32fc_t* b = bVector;
++@@ -176,19 +196,19 @@ static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_u_sse3(lv_32fc
++ // Set up constant scalar vector
++ s = _mm_loadu_ps((float*)v_scalar);
++
++- for(;number < halfPoints; number++){
+++ for (; number < halfPoints; number++) {
++ x = _mm_loadu_ps((float*)b);
++ y = _mm_loadu_ps((float*)a);
++ z = _mm_complexconjugatemul_ps(s, x);
++ z = _mm_add_ps(y, z);
++- _mm_storeu_ps((float*)c,z);
+++ _mm_storeu_ps((float*)c, z);
++
++ a += 2;
++ b += 2;
++ c += 2;
++ }
++
++- if((num_points % 2) != 0) {
+++ if ((num_points % 2) != 0) {
++ *c = *a + lv_conj(*b) * scalar;
++ }
++ }
++@@ -199,14 +219,20 @@ static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_u_sse3(lv_32fc
++ #include <immintrin.h>
++ #include <volk/volk_avx_intrinsics.h>
++
++-static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_a_avx(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, const lv_32fc_t scalar, unsigned int num_points) {
+++static inline void
+++volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_a_avx(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
++ unsigned int number = 0;
++ unsigned int i = 0;
++ const unsigned int quarterPoints = num_points / 4;
++ unsigned int isodd = num_points & 3;
++
++ __m256 x, y, s, z;
++- lv_32fc_t v_scalar[4] = {scalar, scalar, scalar, scalar};
+++ lv_32fc_t v_scalar[4] = { scalar, scalar, scalar, scalar };
++
++ const lv_32fc_t* a = aVector;
++ const lv_32fc_t* b = bVector;
++@@ -215,19 +241,19 @@ static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_a_avx(lv_32fc_
++ // Set up constant scalar vector
++ s = _mm256_load_ps((float*)v_scalar);
++
++- for(;number < quarterPoints; number++) {
+++ for (; number < quarterPoints; number++) {
++ x = _mm256_load_ps((float*)b);
++ y = _mm256_load_ps((float*)a);
++ z = _mm256_complexconjugatemul_ps(s, x);
++ z = _mm256_add_ps(y, z);
++- _mm256_store_ps((float*)c,z);
+++ _mm256_store_ps((float*)c, z);
++
++ a += 4;
++ b += 4;
++ c += 4;
++ }
++
++- for(i = num_points-isodd; i < num_points; i++) {
+++ for (i = num_points - isodd; i < num_points; i++) {
++ *c++ = (*a++) + lv_conj(*b++) * scalar;
++ }
++ }
++@@ -238,12 +264,18 @@ static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_a_avx(lv_32fc_
++ #include <pmmintrin.h>
++ #include <volk/volk_sse3_intrinsics.h>
++
++-static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_a_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, const lv_32fc_t scalar, unsigned int num_points) {
+++static inline void
+++volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_a_sse3(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
++ unsigned int number = 0;
++ const unsigned int halfPoints = num_points / 2;
++
++ __m128 x, y, s, z;
++- lv_32fc_t v_scalar[2] = {scalar, scalar};
+++ lv_32fc_t v_scalar[2] = { scalar, scalar };
++
++ const lv_32fc_t* a = aVector;
++ const lv_32fc_t* b = bVector;
++@@ -252,19 +284,19 @@ static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_a_sse3(lv_32fc
++ // Set up constant scalar vector
++ s = _mm_load_ps((float*)v_scalar);
++
++- for(;number < halfPoints; number++){
+++ for (; number < halfPoints; number++) {
++ x = _mm_load_ps((float*)b);
++ y = _mm_load_ps((float*)a);
++ z = _mm_complexconjugatemul_ps(s, x);
++ z = _mm_add_ps(y, z);
++- _mm_store_ps((float*)c,z);
+++ _mm_store_ps((float*)c, z);
++
++ a += 2;
++ b += 2;
++ c += 2;
++ }
++
++- if((num_points % 2) != 0) {
+++ if ((num_points % 2) != 0) {
++ *c = *a + lv_conj(*b) * scalar;
++ }
++ }
++@@ -272,9 +304,15 @@ static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_a_sse3(lv_32fc
++
++
++ #ifdef LV_HAVE_NEON
++-#include <arm_neon.h>
++-
++-static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_neon(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, const lv_32fc_t scalar, unsigned int num_points){
+++#include <arm_neon.h>
+++
+++static inline void
+++volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_neon(lv_32fc_t* cVector,
+++ const lv_32fc_t* aVector,
+++ const lv_32fc_t* bVector,
+++ const lv_32fc_t scalar,
+++ unsigned int num_points)
+++{
++ const lv_32fc_t* bPtr = bVector;
++ const lv_32fc_t* aPtr = aVector;
++ lv_32fc_t* cPtr = cVector;
++@@ -287,7 +325,7 @@ static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_neon(lv_32fc_t
++ scalar_val.val[0] = vld1q_dup_f32((const float*)&scalar);
++ scalar_val.val[1] = vld1q_dup_f32(((const float*)&scalar) + 1);
++
++- for(number = 0; number < quarter_points; ++number) {
+++ for (number = 0; number < quarter_points; ++number) {
++ a_val = vld2q_f32((float*)aPtr);
++ b_val = vld2q_f32((float*)bPtr);
++ b_val.val[1] = vnegq_f32(b_val.val[1]);
++@@ -310,7 +348,7 @@ static inline void volk_32fc_x2_s32fc_multiply_conjugate_add_32fc_neon(lv_32fc_t
++ cPtr += 4;
++ }
++
++- for(number = quarter_points*4; number < num_points; number++){
+++ for (number = quarter_points * 4; number < num_points; number++) {
++ *cPtr++ = (*aPtr++) + lv_conj(*bPtr++) * scalar;
++ }
++ }
++diff --git a/kernels/volk/volk_32fc_x2_square_dist_32f.h b/kernels/volk/volk_32fc_x2_square_dist_32f.h
++index d6c6dff..75f4072 100644
++--- a/kernels/volk/volk_32fc_x2_square_dist_32f.h
+++++ b/kernels/volk/volk_32fc_x2_square_dist_32f.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32fc_x2_square_dist_32f(float* target, lv_32fc_t* src0, lv_32fc_t* points, unsigned int num_points) {
++- * \endcode
+++ * void volk_32fc_x2_square_dist_32f(float* target, lv_32fc_t* src0, lv_32fc_t* points,
+++ * unsigned int num_points) { \endcode
++ *
++ * \b Inputs
++ * \li src0: The complex input. Only the first point is used.
++@@ -78,183 +78,185 @@
++ #ifndef INCLUDED_volk_32fc_x2_square_dist_32f_a_H
++ #define INCLUDED_volk_32fc_x2_square_dist_32f_a_H
++
++-#include<inttypes.h>
++-#include<stdio.h>
++-#include<volk/volk_complex.h>
+++#include <inttypes.h>
+++#include <stdio.h>
+++#include <volk/volk_complex.h>
++
++ #ifdef LV_HAVE_AVX2
++-#include<immintrin.h>
+++#include <immintrin.h>
++
++-static inline void
++-volk_32fc_x2_square_dist_32f_a_avx2(float* target, lv_32fc_t* src0, lv_32fc_t* points,
++- unsigned int num_points)
+++static inline void volk_32fc_x2_square_dist_32f_a_avx2(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*8;
++- __m128 xmm0, xmm9, xmm10;
++- __m256 xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
++-
++- lv_32fc_t diff;
++- float sq_dist;
++- int bound = num_bytes >> 6;
++- int leftovers0 = (num_bytes >> 5) & 1;
++- int leftovers1 = (num_bytes >> 4) & 1;
++- int leftovers2 = (num_bytes >> 3) & 1;
++- int i = 0;
++-
++- __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
++- xmm1 = _mm256_setzero_ps();
++- xmm2 = _mm256_load_ps((float*)&points[0]);
++- xmm0 = _mm_load_ps((float*)src0);
++- xmm0 = _mm_permute_ps(xmm0, 0b01000100);
++- xmm1 = _mm256_insertf128_ps(xmm1, xmm0, 0);
++- xmm1 = _mm256_insertf128_ps(xmm1, xmm0, 1);
++- xmm3 = _mm256_load_ps((float*)&points[4]);
++-
++- for(; i < bound; ++i) {
++- xmm4 = _mm256_sub_ps(xmm1, xmm2);
++- xmm5 = _mm256_sub_ps(xmm1, xmm3);
++- points += 8;
++- xmm6 = _mm256_mul_ps(xmm4, xmm4);
++- xmm7 = _mm256_mul_ps(xmm5, xmm5);
++-
+++ const unsigned int num_bytes = num_points * 8;
+++ __m128 xmm0, xmm9, xmm10;
+++ __m256 xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
+++
+++ lv_32fc_t diff;
+++ float sq_dist;
+++ int bound = num_bytes >> 6;
+++ int leftovers0 = (num_bytes >> 5) & 1;
+++ int leftovers1 = (num_bytes >> 4) & 1;
+++ int leftovers2 = (num_bytes >> 3) & 1;
+++ int i = 0;
+++
+++ __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
+++ xmm1 = _mm256_setzero_ps();
++ xmm2 = _mm256_load_ps((float*)&points[0]);
+++ xmm0 = _mm_load_ps((float*)src0);
+++ xmm0 = _mm_permute_ps(xmm0, 0b01000100);
+++ xmm1 = _mm256_insertf128_ps(xmm1, xmm0, 0);
+++ xmm1 = _mm256_insertf128_ps(xmm1, xmm0, 1);
+++ xmm3 = _mm256_load_ps((float*)&points[4]);
++
++- xmm4 = _mm256_hadd_ps(xmm6, xmm7);
++- xmm4 = _mm256_permutevar8x32_ps(xmm4, idx);
+++ for (; i < bound; ++i) {
+++ xmm4 = _mm256_sub_ps(xmm1, xmm2);
+++ xmm5 = _mm256_sub_ps(xmm1, xmm3);
+++ points += 8;
+++ xmm6 = _mm256_mul_ps(xmm4, xmm4);
+++ xmm7 = _mm256_mul_ps(xmm5, xmm5);
++
++- xmm3 = _mm256_load_ps((float*)&points[4]);
+++ xmm2 = _mm256_load_ps((float*)&points[0]);
++
++- _mm256_store_ps(target, xmm4);
+++ xmm4 = _mm256_hadd_ps(xmm6, xmm7);
+++ xmm4 = _mm256_permutevar8x32_ps(xmm4, idx);
++
++- target += 8;
++- }
+++ xmm3 = _mm256_load_ps((float*)&points[4]);
++
++- for(i = 0; i < leftovers0; ++i) {
+++ _mm256_store_ps(target, xmm4);
++
++- xmm2 = _mm256_load_ps((float*)&points[0]);
+++ target += 8;
+++ }
++
++- xmm4 = _mm256_sub_ps(xmm1, xmm2);
+++ for (i = 0; i < leftovers0; ++i) {
++
++- points += 4;
+++ xmm2 = _mm256_load_ps((float*)&points[0]);
++
++- xmm6 = _mm256_mul_ps(xmm4, xmm4);
+++ xmm4 = _mm256_sub_ps(xmm1, xmm2);
++
++- xmm4 = _mm256_hadd_ps(xmm6, xmm6);
++- xmm4 = _mm256_permutevar8x32_ps(xmm4, idx);
+++ points += 4;
++
++- xmm9 = _mm256_extractf128_ps(xmm4, 1);
++- _mm_store_ps(target,xmm9);
+++ xmm6 = _mm256_mul_ps(xmm4, xmm4);
++
++- target += 4;
++- }
+++ xmm4 = _mm256_hadd_ps(xmm6, xmm6);
+++ xmm4 = _mm256_permutevar8x32_ps(xmm4, idx);
+++
+++ xmm9 = _mm256_extractf128_ps(xmm4, 1);
+++ _mm_store_ps(target, xmm9);
++
++- for(i = 0; i < leftovers1; ++i) {
++- xmm9 = _mm_load_ps((float*)&points[0]);
+++ target += 4;
+++ }
++
++- xmm10 = _mm_sub_ps(xmm0, xmm9);
+++ for (i = 0; i < leftovers1; ++i) {
+++ xmm9 = _mm_load_ps((float*)&points[0]);
++
++- points += 2;
+++ xmm10 = _mm_sub_ps(xmm0, xmm9);
++
++- xmm9 = _mm_mul_ps(xmm10, xmm10);
+++ points += 2;
++
++- xmm10 = _mm_hadd_ps(xmm9, xmm9);
+++ xmm9 = _mm_mul_ps(xmm10, xmm10);
++
++- _mm_storeh_pi((__m64*)target, xmm10);
+++ xmm10 = _mm_hadd_ps(xmm9, xmm9);
++
++- target += 2;
++- }
+++ _mm_storeh_pi((__m64*)target, xmm10);
++
++- for(i = 0; i < leftovers2; ++i) {
+++ target += 2;
+++ }
++
++- diff = src0[0] - points[0];
+++ for (i = 0; i < leftovers2; ++i) {
++
++- sq_dist = lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff);
+++ diff = src0[0] - points[0];
++
++- target[0] = sq_dist;
++- }
+++ sq_dist = lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff);
+++
+++ target[0] = sq_dist;
+++ }
++ }
++
++ #endif /*LV_HAVE_AVX2*/
++
++ #ifdef LV_HAVE_SSE3
++-#include<xmmintrin.h>
++-#include<pmmintrin.h>
+++#include <pmmintrin.h>
+++#include <xmmintrin.h>
++
++-static inline void
++-volk_32fc_x2_square_dist_32f_a_sse3(float* target, lv_32fc_t* src0, lv_32fc_t* points,
++- unsigned int num_points)
+++static inline void volk_32fc_x2_square_dist_32f_a_sse3(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*8;
+++ const unsigned int num_bytes = num_points * 8;
++
++- __m128 xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
+++ __m128 xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
++
++- lv_32fc_t diff;
++- float sq_dist;
++- int bound = num_bytes >> 5;
++- int i = 0;
+++ lv_32fc_t diff;
+++ float sq_dist;
+++ int bound = num_bytes >> 5;
+++ int i = 0;
++
++- xmm1 = _mm_setzero_ps();
++- xmm1 = _mm_loadl_pi(xmm1, (__m64*)src0);
++- xmm2 = _mm_load_ps((float*)&points[0]);
++- xmm1 = _mm_movelh_ps(xmm1, xmm1);
++- xmm3 = _mm_load_ps((float*)&points[2]);
+++ xmm1 = _mm_setzero_ps();
+++ xmm1 = _mm_loadl_pi(xmm1, (__m64*)src0);
+++ xmm2 = _mm_load_ps((float*)&points[0]);
+++ xmm1 = _mm_movelh_ps(xmm1, xmm1);
+++ xmm3 = _mm_load_ps((float*)&points[2]);
+++
+++ for (; i < bound - 1; ++i) {
+++ xmm4 = _mm_sub_ps(xmm1, xmm2);
+++ xmm5 = _mm_sub_ps(xmm1, xmm3);
+++ points += 4;
+++ xmm6 = _mm_mul_ps(xmm4, xmm4);
+++ xmm7 = _mm_mul_ps(xmm5, xmm5);
+++
+++ xmm2 = _mm_load_ps((float*)&points[0]);
+++
+++ xmm4 = _mm_hadd_ps(xmm6, xmm7);
+++
+++ xmm3 = _mm_load_ps((float*)&points[2]);
+++
+++ _mm_store_ps(target, xmm4);
+++
+++ target += 4;
+++ }
++
++- for(; i < bound - 1; ++i) {
++ xmm4 = _mm_sub_ps(xmm1, xmm2);
++ xmm5 = _mm_sub_ps(xmm1, xmm3);
+++
++ points += 4;
++ xmm6 = _mm_mul_ps(xmm4, xmm4);
++ xmm7 = _mm_mul_ps(xmm5, xmm5);
++
++- xmm2 = _mm_load_ps((float*)&points[0]);
++-
++ xmm4 = _mm_hadd_ps(xmm6, xmm7);
++
++- xmm3 = _mm_load_ps((float*)&points[2]);
++-
++ _mm_store_ps(target, xmm4);
++
++ target += 4;
++- }
++-
++- xmm4 = _mm_sub_ps(xmm1, xmm2);
++- xmm5 = _mm_sub_ps(xmm1, xmm3);
++-
++- points += 4;
++- xmm6 = _mm_mul_ps(xmm4, xmm4);
++- xmm7 = _mm_mul_ps(xmm5, xmm5);
++
++- xmm4 = _mm_hadd_ps(xmm6, xmm7);
+++ if (num_bytes >> 4 & 1) {
++
++- _mm_store_ps(target, xmm4);
+++ xmm2 = _mm_load_ps((float*)&points[0]);
++
++- target += 4;
+++ xmm4 = _mm_sub_ps(xmm1, xmm2);
++
++- if (num_bytes >> 4 & 1) {
+++ points += 2;
++
++- xmm2 = _mm_load_ps((float*)&points[0]);
++-
++- xmm4 = _mm_sub_ps(xmm1, xmm2);
+++ xmm6 = _mm_mul_ps(xmm4, xmm4);
++
++- points += 2;
++-
++- xmm6 = _mm_mul_ps(xmm4, xmm4);
+++ xmm4 = _mm_hadd_ps(xmm6, xmm6);
++
++- xmm4 = _mm_hadd_ps(xmm6, xmm6);
+++ _mm_storeh_pi((__m64*)target, xmm4);
++
++- _mm_storeh_pi((__m64*)target, xmm4);
+++ target += 2;
+++ }
++
++- target += 2;
++- }
+++ if (num_bytes >> 3 & 1) {
++
++- if (num_bytes >> 3 & 1) {
+++ diff = src0[0] - points[0];
++
++- diff = src0[0] - points[0];
+++ sq_dist = lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff);
++
++- sq_dist = lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff);
++-
++- target[0] = sq_dist;
++- }
+++ target[0] = sq_dist;
+++ }
++ }
++
++ #endif /*LV_HAVE_SSE3*/
++@@ -262,55 +264,58 @@ volk_32fc_x2_square_dist_32f_a_sse3(float* target, lv_32fc_t* src0, lv_32fc_t* p
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++-static inline void
++-volk_32fc_x2_square_dist_32f_neon(float* target, lv_32fc_t* src0, lv_32fc_t* points, unsigned int num_points)
+++static inline void volk_32fc_x2_square_dist_32f_neon(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ unsigned int num_points)
++ {
++- const unsigned int quarter_points = num_points / 4;
++- unsigned int number;
++-
++- float32x4x2_t a_vec, b_vec;
++- float32x4x2_t diff_vec;
++- float32x4_t tmp, tmp1, dist_sq;
++- a_vec.val[0] = vdupq_n_f32( lv_creal(src0[0]) );
++- a_vec.val[1] = vdupq_n_f32( lv_cimag(src0[0]) );
++- for(number=0; number < quarter_points; ++number) {
++- b_vec = vld2q_f32((float*)points);
++- diff_vec.val[0] = vsubq_f32(a_vec.val[0], b_vec.val[0]);
++- diff_vec.val[1] = vsubq_f32(a_vec.val[1], b_vec.val[1]);
++- tmp = vmulq_f32(diff_vec.val[0], diff_vec.val[0]);
++- tmp1 = vmulq_f32(diff_vec.val[1], diff_vec.val[1]);
++-
++- dist_sq = vaddq_f32(tmp, tmp1);
++- vst1q_f32(target, dist_sq);
++- points += 4;
++- target += 4;
++- }
++- for(number=quarter_points*4; number < num_points; ++number) {
++- lv_32fc_t diff = src0[0] - *points++;
++- *target++ = lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff);
++- }
+++ const unsigned int quarter_points = num_points / 4;
+++ unsigned int number;
+++
+++ float32x4x2_t a_vec, b_vec;
+++ float32x4x2_t diff_vec;
+++ float32x4_t tmp, tmp1, dist_sq;
+++ a_vec.val[0] = vdupq_n_f32(lv_creal(src0[0]));
+++ a_vec.val[1] = vdupq_n_f32(lv_cimag(src0[0]));
+++ for (number = 0; number < quarter_points; ++number) {
+++ b_vec = vld2q_f32((float*)points);
+++ diff_vec.val[0] = vsubq_f32(a_vec.val[0], b_vec.val[0]);
+++ diff_vec.val[1] = vsubq_f32(a_vec.val[1], b_vec.val[1]);
+++ tmp = vmulq_f32(diff_vec.val[0], diff_vec.val[0]);
+++ tmp1 = vmulq_f32(diff_vec.val[1], diff_vec.val[1]);
+++
+++ dist_sq = vaddq_f32(tmp, tmp1);
+++ vst1q_f32(target, dist_sq);
+++ points += 4;
+++ target += 4;
+++ }
+++ for (number = quarter_points * 4; number < num_points; ++number) {
+++ lv_32fc_t diff = src0[0] - *points++;
+++ *target++ = lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void
++-volk_32fc_x2_square_dist_32f_generic(float* target, lv_32fc_t* src0, lv_32fc_t* points,
++- unsigned int num_points)
+++static inline void volk_32fc_x2_square_dist_32f_generic(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*8;
+++ const unsigned int num_bytes = num_points * 8;
++
++- lv_32fc_t diff;
++- float sq_dist;
++- unsigned int i = 0;
+++ lv_32fc_t diff;
+++ float sq_dist;
+++ unsigned int i = 0;
++
++- for(; i < num_bytes >> 3; ++i) {
++- diff = src0[0] - points[i];
+++ for (; i<num_bytes>> 3; ++i) {
+++ diff = src0[0] - points[i];
++
++- sq_dist = lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff);
+++ sq_dist = lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff);
++
++- target[i] = sq_dist;
++- }
+++ target[i] = sq_dist;
+++ }
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -321,80 +326,85 @@ volk_32fc_x2_square_dist_32f_generic(float* target, lv_32fc_t* src0, lv_32fc_t*
++ #ifndef INCLUDED_volk_32fc_x2_square_dist_32f_u_H
++ #define INCLUDED_volk_32fc_x2_square_dist_32f_u_H
++
++-#include<inttypes.h>
++-#include<stdio.h>
++-#include<volk/volk_complex.h>
+++#include <inttypes.h>
+++#include <stdio.h>
+++#include <volk/volk_complex.h>
++
++ #ifdef LV_HAVE_AVX2
++-#include<immintrin.h>
+++#include <immintrin.h>
++
++-static inline void
++-volk_32fc_x2_square_dist_32f_u_avx2(float* target, lv_32fc_t* src0, lv_32fc_t* points,
++- unsigned int num_points)
+++static inline void volk_32fc_x2_square_dist_32f_u_avx2(float* target,
+++ lv_32fc_t* src0,
+++ lv_32fc_t* points,
+++ unsigned int num_points)
++ {
++- const unsigned int num_bytes = num_points*8;
++- __m128 xmm0, xmm9;
++- __m256 xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
++-
++- lv_32fc_t diff;
++- float sq_dist;
++- int bound = num_bytes >> 6;
++- int leftovers1 = (num_bytes >> 3) & 0b11;
++- int i = 0;
++-
++- __m256i idx = _mm256_set_epi32(7,6,3,2,5,4,1,0);
++- xmm1 = _mm256_setzero_ps();
++- xmm0 = _mm_loadu_ps((float*)src0);
++- xmm0 = _mm_permute_ps(xmm0, 0b01000100);
++- xmm1 = _mm256_insertf128_ps(xmm1, xmm0, 0);
++- xmm1 = _mm256_insertf128_ps(xmm1, xmm0, 1);
++-
++- for(; i < bound; ++i) {
+++ const unsigned int num_bytes = num_points * 8;
+++ __m128 xmm0, xmm9;
+++ __m256 xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
+++
+++ lv_32fc_t diff;
+++ float sq_dist;
+++ int bound = num_bytes >> 6;
+++ int leftovers1 = (num_bytes >> 3) & 0b11;
+++ int i = 0;
+++
+++ __m256i idx = _mm256_set_epi32(7, 6, 3, 2, 5, 4, 1, 0);
+++ xmm1 = _mm256_setzero_ps();
++ xmm2 = _mm256_loadu_ps((float*)&points[0]);
+++ xmm0 = _mm_loadu_ps((float*)src0);
+++ xmm0 = _mm_permute_ps(xmm0, 0b01000100);
+++ xmm1 = _mm256_insertf128_ps(xmm1, xmm0, 0);
+++ xmm1 = _mm256_insertf128_ps(xmm1, xmm0, 1);
++ xmm3 = _mm256_loadu_ps((float*)&points[4]);
++- xmm4 = _mm256_sub_ps(xmm1, xmm2);
++- xmm5 = _mm256_sub_ps(xmm1, xmm3);
++- points += 8;
++- xmm6 = _mm256_mul_ps(xmm4, xmm4);
++- xmm7 = _mm256_mul_ps(xmm5, xmm5);
++
++- xmm4 = _mm256_hadd_ps(xmm6, xmm7);
++- xmm4 = _mm256_permutevar8x32_ps(xmm4, idx);
+++ for (; i < bound; ++i) {
+++ xmm4 = _mm256_sub_ps(xmm1, xmm2);
+++ xmm5 = _mm256_sub_ps(xmm1, xmm3);
+++ points += 8;
+++ xmm6 = _mm256_mul_ps(xmm4, xmm4);
+++ xmm7 = _mm256_mul_ps(xmm5, xmm5);
++
++- _mm256_storeu_ps(target, xmm4);
+++ xmm2 = _mm256_loadu_ps((float*)&points[0]);
++
++- target += 8;
++- }
+++ xmm4 = _mm256_hadd_ps(xmm6, xmm7);
+++ xmm4 = _mm256_permutevar8x32_ps(xmm4, idx);
++
++- if (num_bytes >> 5 & 1) {
+++ xmm3 = _mm256_loadu_ps((float*)&points[4]);
++
++- xmm2 = _mm256_loadu_ps((float*)&points[0]);
+++ _mm256_storeu_ps(target, xmm4);
++
++- xmm4 = _mm256_sub_ps(xmm1, xmm2);
+++ target += 8;
+++ }
++
++- points += 4;
+++ if (num_bytes >> 5 & 1) {
++
++- xmm6 = _mm256_mul_ps(xmm4, xmm4);
+++ xmm2 = _mm256_loadu_ps((float*)&points[0]);
++
++- xmm4 = _mm256_hadd_ps(xmm6, xmm6);
++- xmm4 = _mm256_permutevar8x32_ps(xmm4, idx);
+++ xmm4 = _mm256_sub_ps(xmm1, xmm2);
++
++- xmm9 = _mm256_extractf128_ps(xmm4, 1);
++- _mm_storeu_ps(target,xmm9);
+++ points += 4;
++
++- target += 4;
++- }
+++ xmm6 = _mm256_mul_ps(xmm4, xmm4);
+++
+++ xmm4 = _mm256_hadd_ps(xmm6, xmm6);
+++ xmm4 = _mm256_permutevar8x32_ps(xmm4, idx);
+++
+++ xmm9 = _mm256_extractf128_ps(xmm4, 1);
+++ _mm_storeu_ps(target, xmm9);
+++
+++ target += 4;
+++ }
++
++- for(i = 0; i < leftovers1; ++i) {
+++ for (i = 0; i < leftovers1; ++i) {
++
++- diff = src0[0] - points[0];
++- points += 1;
+++ diff = src0[0] - points[0];
+++ points += 1;
++
++- sq_dist = lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff);
+++ sq_dist = lv_creal(diff) * lv_creal(diff) + lv_cimag(diff) * lv_cimag(diff);
++
++- target[0] = sq_dist;
++- target += 1;
++- }
+++ target[0] = sq_dist;
+++ target += 1;
+++ }
++ }
++
++ #endif /*LV_HAVE_AVX2*/
++diff --git a/kernels/volk/volk_32i_s32f_convert_32f.h b/kernels/volk/volk_32i_s32f_convert_32f.h
++index 87d94f9..6b67cdb 100644
++--- a/kernels/volk/volk_32i_s32f_convert_32f.h
+++++ b/kernels/volk/volk_32i_s32f_convert_32f.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32i_s32f_convert_32f(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points)
++- * \endcode
+++ * void volk_32i_s32f_convert_32f(float* outputVector, const int32_t* inputVector, const
+++ * float scalar, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li inputVector: The vector of 32-bit integers.
++@@ -70,37 +70,38 @@
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32i_s32f_convert_32f_u_avx512f(float* outputVector, const int32_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32i_s32f_convert_32f_u_avx512f(float* outputVector,
+++ const int32_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int onesixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int onesixteenthPoints = num_points / 16;
++
++- float* outputVectorPtr = outputVector;
++- const float iScalar = 1.0 / scalar;
++- __m512 invScalar = _mm512_set1_ps(iScalar);
++- int32_t* inputPtr = (int32_t*)inputVector;
++- __m512i inputVal;
++- __m512 ret;
+++ float* outputVectorPtr = outputVector;
+++ const float iScalar = 1.0 / scalar;
+++ __m512 invScalar = _mm512_set1_ps(iScalar);
+++ int32_t* inputPtr = (int32_t*)inputVector;
+++ __m512i inputVal;
+++ __m512 ret;
++
++- for(;number < onesixteenthPoints; number++){
++- // Load the values
++- inputVal = _mm512_loadu_si512((__m512i*)inputPtr);
+++ for (; number < onesixteenthPoints; number++) {
+++ // Load the values
+++ inputVal = _mm512_loadu_si512((__m512i*)inputPtr);
++
++- ret = _mm512_cvtepi32_ps(inputVal);
++- ret = _mm512_mul_ps(ret, invScalar);
+++ ret = _mm512_cvtepi32_ps(inputVal);
+++ ret = _mm512_mul_ps(ret, invScalar);
++
++- _mm512_storeu_ps(outputVectorPtr, ret);
+++ _mm512_storeu_ps(outputVectorPtr, ret);
++
++- outputVectorPtr += 16;
++- inputPtr += 16;
++- }
+++ outputVectorPtr += 16;
+++ inputPtr += 16;
+++ }
++
++- number = onesixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] =((float)(inputVector[number])) * iScalar;
++- }
+++ number = onesixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = ((float)(inputVector[number])) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++@@ -108,37 +109,38 @@ volk_32i_s32f_convert_32f_u_avx512f(float* outputVector, const int32_t* inputVec
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32i_s32f_convert_32f_u_avx2(float* outputVector, const int32_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32i_s32f_convert_32f_u_avx2(float* outputVector,
+++ const int32_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int oneEightPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int oneEightPoints = num_points / 8;
++
++- float* outputVectorPtr = outputVector;
++- const float iScalar = 1.0 / scalar;
++- __m256 invScalar = _mm256_set1_ps(iScalar);
++- int32_t* inputPtr = (int32_t*)inputVector;
++- __m256i inputVal;
++- __m256 ret;
+++ float* outputVectorPtr = outputVector;
+++ const float iScalar = 1.0 / scalar;
+++ __m256 invScalar = _mm256_set1_ps(iScalar);
+++ int32_t* inputPtr = (int32_t*)inputVector;
+++ __m256i inputVal;
+++ __m256 ret;
++
++- for(;number < oneEightPoints; number++){
++- // Load the 4 values
++- inputVal = _mm256_loadu_si256((__m256i*)inputPtr);
+++ for (; number < oneEightPoints; number++) {
+++ // Load the 4 values
+++ inputVal = _mm256_loadu_si256((__m256i*)inputPtr);
++
++- ret = _mm256_cvtepi32_ps(inputVal);
++- ret = _mm256_mul_ps(ret, invScalar);
+++ ret = _mm256_cvtepi32_ps(inputVal);
+++ ret = _mm256_mul_ps(ret, invScalar);
++
++- _mm256_storeu_ps(outputVectorPtr, ret);
+++ _mm256_storeu_ps(outputVectorPtr, ret);
++
++- outputVectorPtr += 8;
++- inputPtr += 8;
++- }
+++ outputVectorPtr += 8;
+++ inputPtr += 8;
+++ }
++
++- number = oneEightPoints * 8;
++- for(; number < num_points; number++){
++- outputVector[number] =((float)(inputVector[number])) * iScalar;
++- }
+++ number = oneEightPoints * 8;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = ((float)(inputVector[number])) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -146,62 +148,63 @@ volk_32i_s32f_convert_32f_u_avx2(float* outputVector, const int32_t* inputVector
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32i_s32f_convert_32f_u_sse2(float* outputVector, const int32_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32i_s32f_convert_32f_u_sse2(float* outputVector,
+++ const int32_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* outputVectorPtr = outputVector;
++- const float iScalar = 1.0 / scalar;
++- __m128 invScalar = _mm_set_ps1(iScalar);
++- int32_t* inputPtr = (int32_t*)inputVector;
++- __m128i inputVal;
++- __m128 ret;
+++ float* outputVectorPtr = outputVector;
+++ const float iScalar = 1.0 / scalar;
+++ __m128 invScalar = _mm_set_ps1(iScalar);
+++ int32_t* inputPtr = (int32_t*)inputVector;
+++ __m128i inputVal;
+++ __m128 ret;
++
++- for(;number < quarterPoints; number++){
++- // Load the 4 values
++- inputVal = _mm_loadu_si128((__m128i*)inputPtr);
+++ for (; number < quarterPoints; number++) {
+++ // Load the 4 values
+++ inputVal = _mm_loadu_si128((__m128i*)inputPtr);
++
++- ret = _mm_cvtepi32_ps(inputVal);
++- ret = _mm_mul_ps(ret, invScalar);
+++ ret = _mm_cvtepi32_ps(inputVal);
+++ ret = _mm_mul_ps(ret, invScalar);
++
++- _mm_storeu_ps(outputVectorPtr, ret);
+++ _mm_storeu_ps(outputVectorPtr, ret);
++
++- outputVectorPtr += 4;
++- inputPtr += 4;
++- }
+++ outputVectorPtr += 4;
+++ inputPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- outputVector[number] =((float)(inputVector[number])) * iScalar;
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = ((float)(inputVector[number])) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32i_s32f_convert_32f_generic(float* outputVector, const int32_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32i_s32f_convert_32f_generic(float* outputVector,
+++ const int32_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* outputVectorPtr = outputVector;
++- const int32_t* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++- const float iScalar = 1.0 / scalar;
++-
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((float)(*inputVectorPtr++)) * iScalar;
++- }
+++ float* outputVectorPtr = outputVector;
+++ const int32_t* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++ const float iScalar = 1.0 / scalar;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((float)(*inputVectorPtr++)) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #endif /* INCLUDED_volk_32i_s32f_convert_32f_u_H */
++
++
++-
++ #ifndef INCLUDED_volk_32i_s32f_convert_32f_a_H
++ #define INCLUDED_volk_32i_s32f_convert_32f_a_H
++
++@@ -211,74 +214,76 @@ volk_32i_s32f_convert_32f_generic(float* outputVector, const int32_t* inputVecto
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32i_s32f_convert_32f_a_avx512f(float* outputVector, const int32_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32i_s32f_convert_32f_a_avx512f(float* outputVector,
+++ const int32_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int onesixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int onesixteenthPoints = num_points / 16;
++
++- float* outputVectorPtr = outputVector;
++- const float iScalar = 1.0 / scalar;
++- __m512 invScalar = _mm512_set1_ps(iScalar);
++- int32_t* inputPtr = (int32_t*)inputVector;
++- __m512i inputVal;
++- __m512 ret;
+++ float* outputVectorPtr = outputVector;
+++ const float iScalar = 1.0 / scalar;
+++ __m512 invScalar = _mm512_set1_ps(iScalar);
+++ int32_t* inputPtr = (int32_t*)inputVector;
+++ __m512i inputVal;
+++ __m512 ret;
++
++- for(;number < onesixteenthPoints; number++){
++- // Load the values
++- inputVal = _mm512_load_si512((__m512i*)inputPtr);
+++ for (; number < onesixteenthPoints; number++) {
+++ // Load the values
+++ inputVal = _mm512_load_si512((__m512i*)inputPtr);
++
++- ret = _mm512_cvtepi32_ps(inputVal);
++- ret = _mm512_mul_ps(ret, invScalar);
+++ ret = _mm512_cvtepi32_ps(inputVal);
+++ ret = _mm512_mul_ps(ret, invScalar);
++
++- _mm512_store_ps(outputVectorPtr, ret);
+++ _mm512_store_ps(outputVectorPtr, ret);
++
++- outputVectorPtr += 16;
++- inputPtr += 16;
++- }
+++ outputVectorPtr += 16;
+++ inputPtr += 16;
+++ }
++
++- number = onesixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] =((float)(inputVector[number])) * iScalar;
++- }
+++ number = onesixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = ((float)(inputVector[number])) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32i_s32f_convert_32f_a_avx2(float* outputVector, const int32_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32i_s32f_convert_32f_a_avx2(float* outputVector,
+++ const int32_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int oneEightPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int oneEightPoints = num_points / 8;
++
++- float* outputVectorPtr = outputVector;
++- const float iScalar = 1.0 / scalar;
++- __m256 invScalar = _mm256_set1_ps(iScalar);
++- int32_t* inputPtr = (int32_t*)inputVector;
++- __m256i inputVal;
++- __m256 ret;
+++ float* outputVectorPtr = outputVector;
+++ const float iScalar = 1.0 / scalar;
+++ __m256 invScalar = _mm256_set1_ps(iScalar);
+++ int32_t* inputPtr = (int32_t*)inputVector;
+++ __m256i inputVal;
+++ __m256 ret;
++
++- for(;number < oneEightPoints; number++){
++- // Load the 4 values
++- inputVal = _mm256_load_si256((__m256i*)inputPtr);
+++ for (; number < oneEightPoints; number++) {
+++ // Load the 4 values
+++ inputVal = _mm256_load_si256((__m256i*)inputPtr);
++
++- ret = _mm256_cvtepi32_ps(inputVal);
++- ret = _mm256_mul_ps(ret, invScalar);
+++ ret = _mm256_cvtepi32_ps(inputVal);
+++ ret = _mm256_mul_ps(ret, invScalar);
++
++- _mm256_store_ps(outputVectorPtr, ret);
+++ _mm256_store_ps(outputVectorPtr, ret);
++
++- outputVectorPtr += 8;
++- inputPtr += 8;
++- }
+++ outputVectorPtr += 8;
+++ inputPtr += 8;
+++ }
++
++- number = oneEightPoints * 8;
++- for(; number < num_points; number++){
++- outputVector[number] =((float)(inputVector[number])) * iScalar;
++- }
+++ number = oneEightPoints * 8;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = ((float)(inputVector[number])) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -286,59 +291,59 @@ volk_32i_s32f_convert_32f_a_avx2(float* outputVector, const int32_t* inputVector
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_32i_s32f_convert_32f_a_sse2(float* outputVector, const int32_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32i_s32f_convert_32f_a_sse2(float* outputVector,
+++ const int32_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* outputVectorPtr = outputVector;
++- const float iScalar = 1.0 / scalar;
++- __m128 invScalar = _mm_set_ps1(iScalar);
++- int32_t* inputPtr = (int32_t*)inputVector;
++- __m128i inputVal;
++- __m128 ret;
+++ float* outputVectorPtr = outputVector;
+++ const float iScalar = 1.0 / scalar;
+++ __m128 invScalar = _mm_set_ps1(iScalar);
+++ int32_t* inputPtr = (int32_t*)inputVector;
+++ __m128i inputVal;
+++ __m128 ret;
++
++- for(;number < quarterPoints; number++){
++- // Load the 4 values
++- inputVal = _mm_load_si128((__m128i*)inputPtr);
+++ for (; number < quarterPoints; number++) {
+++ // Load the 4 values
+++ inputVal = _mm_load_si128((__m128i*)inputPtr);
++
++- ret = _mm_cvtepi32_ps(inputVal);
++- ret = _mm_mul_ps(ret, invScalar);
+++ ret = _mm_cvtepi32_ps(inputVal);
+++ ret = _mm_mul_ps(ret, invScalar);
++
++- _mm_store_ps(outputVectorPtr, ret);
+++ _mm_store_ps(outputVectorPtr, ret);
++
++- outputVectorPtr += 4;
++- inputPtr += 4;
++- }
+++ outputVectorPtr += 4;
+++ inputPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- outputVector[number] =((float)(inputVector[number])) * iScalar;
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = ((float)(inputVector[number])) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32i_s32f_convert_32f_a_generic(float* outputVector, const int32_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_32i_s32f_convert_32f_a_generic(float* outputVector,
+++ const int32_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* outputVectorPtr = outputVector;
++- const int32_t* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++- const float iScalar = 1.0 / scalar;
++-
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((float)(*inputVectorPtr++)) * iScalar;
++- }
+++ float* outputVectorPtr = outputVector;
+++ const int32_t* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++ const float iScalar = 1.0 / scalar;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((float)(*inputVectorPtr++)) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++-
++ #endif /* INCLUDED_volk_32i_s32f_convert_32f_a_H */
++diff --git a/kernels/volk/volk_32i_x2_and_32i.h b/kernels/volk/volk_32i_x2_and_32i.h
++index 76f0175..755cfdc 100644
++--- a/kernels/volk/volk_32i_x2_and_32i.h
+++++ b/kernels/volk/volk_32i_x2_and_32i.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32i_x2_and_32i(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32i_x2_and_32i(int32_t* cVector, const int32_t* aVector, const int32_t*
+++ * bVector, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: Input vector of samples.
++@@ -87,72 +87,75 @@
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32i_x2_and_32i_a_avx512f(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_and_32i_a_avx512f(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- int32_t* cPtr = (int32_t*)cVector;
++- const int32_t* aPtr = (int32_t*)aVector;
++- const int32_t* bPtr = (int32_t*)bVector;
+++ int32_t* cPtr = (int32_t*)cVector;
+++ const int32_t* aPtr = (int32_t*)aVector;
+++ const int32_t* bPtr = (int32_t*)bVector;
++
++- __m512i aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
+++ __m512i aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
++
++- aVal = _mm512_load_si512(aPtr);
++- bVal = _mm512_load_si512(bPtr);
+++ aVal = _mm512_load_si512(aPtr);
+++ bVal = _mm512_load_si512(bPtr);
++
++- cVal = _mm512_and_si512(aVal, bVal);
+++ cVal = _mm512_and_si512(aVal, bVal);
++
++- _mm512_store_si512(cPtr,cVal); // Store the results back into the C container
+++ _mm512_store_si512(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- cVector[number] = aVector[number] & bVector[number];
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ cVector[number] = aVector[number] & bVector[number];
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32i_x2_and_32i_a_avx2(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_and_32i_a_avx2(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int oneEightPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int oneEightPoints = num_points / 8;
++
++- int32_t* cPtr = cVector;
++- const int32_t* aPtr = aVector;
++- const int32_t* bPtr = bVector;
+++ int32_t* cPtr = cVector;
+++ const int32_t* aPtr = aVector;
+++ const int32_t* bPtr = bVector;
++
++- __m256i aVal, bVal, cVal;
++- for(;number < oneEightPoints; number++){
+++ __m256i aVal, bVal, cVal;
+++ for (; number < oneEightPoints; number++) {
++
++- aVal = _mm256_load_si256((__m256i*)aPtr);
++- bVal = _mm256_load_si256((__m256i*)bPtr);
+++ aVal = _mm256_load_si256((__m256i*)aPtr);
+++ bVal = _mm256_load_si256((__m256i*)bPtr);
++
++- cVal = _mm256_and_si256(aVal, bVal);
+++ cVal = _mm256_and_si256(aVal, bVal);
++
++- _mm256_store_si256((__m256i*)cPtr,cVal); // Store the results back into the C container
+++ _mm256_store_si256((__m256i*)cPtr,
+++ cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = oneEightPoints * 8;
++- for(;number < num_points; number++){
++- cVector[number] = aVector[number] & bVector[number];
++- }
+++ number = oneEightPoints * 8;
+++ for (; number < num_points; number++) {
+++ cVector[number] = aVector[number] & bVector[number];
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -160,36 +163,37 @@ volk_32i_x2_and_32i_a_avx2(int32_t* cVector, const int32_t* aVector,
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32i_x2_and_32i_a_sse(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_and_32i_a_sse(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = (float*)cVector;
++- const float* aPtr = (float*)aVector;
++- const float* bPtr = (float*)bVector;
+++ float* cPtr = (float*)cVector;
+++ const float* aPtr = (float*)aVector;
+++ const float* bPtr = (float*)bVector;
++
++- __m128 aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
+++ __m128 aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm_load_ps(aPtr);
++- bVal = _mm_load_ps(bPtr);
+++ aVal = _mm_load_ps(aPtr);
+++ bVal = _mm_load_ps(bPtr);
++
++- cVal = _mm_and_ps(aVal, bVal);
+++ cVal = _mm_and_ps(aVal, bVal);
++
++- _mm_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- cVector[number] = aVector[number] & bVector[number];
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ cVector[number] = aVector[number] & bVector[number];
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -197,62 +201,67 @@ volk_32i_x2_and_32i_a_sse(int32_t* cVector, const int32_t* aVector,
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32i_x2_and_32i_neon(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_and_32i_neon(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- int32_t* cPtr = cVector;
++- const int32_t* aPtr = aVector;
++- const int32_t* bPtr= bVector;
++- unsigned int number = 0;
++- unsigned int quarter_points = num_points / 4;
++-
++- int32x4_t a_val, b_val, c_val;
++-
++- for(number = 0; number < quarter_points; number++){
++- a_val = vld1q_s32(aPtr);
++- b_val = vld1q_s32(bPtr);
++- c_val = vandq_s32(a_val, b_val);
++- vst1q_s32(cPtr, c_val);
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
++-
++- for(number = quarter_points * 4; number < num_points; number++){
++- *cPtr++ = (*aPtr++) & (*bPtr++);
++- }
+++ int32_t* cPtr = cVector;
+++ const int32_t* aPtr = aVector;
+++ const int32_t* bPtr = bVector;
+++ unsigned int number = 0;
+++ unsigned int quarter_points = num_points / 4;
+++
+++ int32x4_t a_val, b_val, c_val;
+++
+++ for (number = 0; number < quarter_points; number++) {
+++ a_val = vld1q_s32(aPtr);
+++ b_val = vld1q_s32(bPtr);
+++ c_val = vandq_s32(a_val, b_val);
+++ vst1q_s32(cPtr, c_val);
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) & (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32i_x2_and_32i_generic(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_and_32i_generic(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- int32_t* cPtr = cVector;
++- const int32_t* aPtr = aVector;
++- const int32_t* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) & (*bPtr++);
++- }
+++ int32_t* cPtr = cVector;
+++ const int32_t* aPtr = aVector;
+++ const int32_t* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) & (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++ #ifdef LV_HAVE_ORC
++-extern void
++-volk_32i_x2_and_32i_a_orc_impl(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points);
++-
++-static inline void
++-volk_32i_x2_and_32i_u_orc(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++extern void volk_32i_x2_and_32i_a_orc_impl(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points);
+++
+++static inline void volk_32i_x2_and_32i_u_orc(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- volk_32i_x2_and_32i_a_orc_impl(cVector, aVector, bVector, num_points);
+++ volk_32i_x2_and_32i_a_orc_impl(cVector, aVector, bVector, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++@@ -269,72 +278,75 @@ volk_32i_x2_and_32i_u_orc(int32_t* cVector, const int32_t* aVector,
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32i_x2_and_32i_u_avx512f(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_and_32i_u_avx512f(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- int32_t* cPtr = (int32_t*)cVector;
++- const int32_t* aPtr = (int32_t*)aVector;
++- const int32_t* bPtr = (int32_t*)bVector;
+++ int32_t* cPtr = (int32_t*)cVector;
+++ const int32_t* aPtr = (int32_t*)aVector;
+++ const int32_t* bPtr = (int32_t*)bVector;
++
++- __m512i aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
+++ __m512i aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
++
++- aVal = _mm512_loadu_si512(aPtr);
++- bVal = _mm512_loadu_si512(bPtr);
+++ aVal = _mm512_loadu_si512(aPtr);
+++ bVal = _mm512_loadu_si512(bPtr);
++
++- cVal = _mm512_and_si512(aVal, bVal);
+++ cVal = _mm512_and_si512(aVal, bVal);
++
++- _mm512_storeu_si512(cPtr,cVal); // Store the results back into the C container
+++ _mm512_storeu_si512(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- cVector[number] = aVector[number] & bVector[number];
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ cVector[number] = aVector[number] & bVector[number];
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32i_x2_and_32i_u_avx2(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_and_32i_u_avx2(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int oneEightPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int oneEightPoints = num_points / 8;
++
++- int32_t* cPtr = cVector;
++- const int32_t* aPtr = aVector;
++- const int32_t* bPtr = bVector;
+++ int32_t* cPtr = cVector;
+++ const int32_t* aPtr = aVector;
+++ const int32_t* bPtr = bVector;
++
++- __m256i aVal, bVal, cVal;
++- for(;number < oneEightPoints; number++){
+++ __m256i aVal, bVal, cVal;
+++ for (; number < oneEightPoints; number++) {
++
++- aVal = _mm256_loadu_si256((__m256i*)aPtr);
++- bVal = _mm256_loadu_si256((__m256i*)bPtr);
+++ aVal = _mm256_loadu_si256((__m256i*)aPtr);
+++ bVal = _mm256_loadu_si256((__m256i*)bPtr);
++
++- cVal = _mm256_and_si256(aVal, bVal);
+++ cVal = _mm256_and_si256(aVal, bVal);
++
++- _mm256_storeu_si256((__m256i*)cPtr,cVal); // Store the results back into the C container
+++ _mm256_storeu_si256((__m256i*)cPtr,
+++ cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = oneEightPoints * 8;
++- for(;number < num_points; number++){
++- cVector[number] = aVector[number] & bVector[number];
++- }
+++ number = oneEightPoints * 8;
+++ for (; number < num_points; number++) {
+++ cVector[number] = aVector[number] & bVector[number];
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_32i_x2_or_32i.h b/kernels/volk/volk_32i_x2_or_32i.h
++index be4c086..b03db89 100644
++--- a/kernels/volk/volk_32i_x2_or_32i.h
+++++ b/kernels/volk/volk_32i_x2_or_32i.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_32i_x2_or_32i(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_32i_x2_or_32i(int32_t* cVector, const int32_t* aVector, const int32_t*
+++ * bVector, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: Input vector of samples.
++@@ -87,72 +87,75 @@
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32i_x2_or_32i_a_avx512f(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_or_32i_a_avx512f(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- int32_t* cPtr = (int32_t*)cVector;
++- const int32_t* aPtr = (int32_t*)aVector;
++- const int32_t* bPtr = (int32_t*)bVector;
+++ int32_t* cPtr = (int32_t*)cVector;
+++ const int32_t* aPtr = (int32_t*)aVector;
+++ const int32_t* bPtr = (int32_t*)bVector;
++
++- __m512i aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
+++ __m512i aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
++
++- aVal = _mm512_load_si512(aPtr);
++- bVal = _mm512_load_si512(bPtr);
+++ aVal = _mm512_load_si512(aPtr);
+++ bVal = _mm512_load_si512(bPtr);
++
++- cVal = _mm512_or_si512(aVal, bVal);
+++ cVal = _mm512_or_si512(aVal, bVal);
++
++- _mm512_store_si512(cPtr,cVal); // Store the results back into the C container
+++ _mm512_store_si512(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- cVector[number] = aVector[number] | bVector[number];
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ cVector[number] = aVector[number] | bVector[number];
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32i_x2_or_32i_a_avx2(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_or_32i_a_avx2(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int oneEightPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int oneEightPoints = num_points / 8;
++
++- int32_t* cPtr = cVector;
++- const int32_t* aPtr = aVector;
++- const int32_t* bPtr = bVector;
+++ int32_t* cPtr = cVector;
+++ const int32_t* aPtr = aVector;
+++ const int32_t* bPtr = bVector;
++
++- __m256i aVal, bVal, cVal;
++- for(;number < oneEightPoints; number++){
+++ __m256i aVal, bVal, cVal;
+++ for (; number < oneEightPoints; number++) {
++
++- aVal = _mm256_load_si256((__m256i*)aPtr);
++- bVal = _mm256_load_si256((__m256i*)bPtr);
+++ aVal = _mm256_load_si256((__m256i*)aPtr);
+++ bVal = _mm256_load_si256((__m256i*)bPtr);
++
++- cVal = _mm256_or_si256(aVal, bVal);
+++ cVal = _mm256_or_si256(aVal, bVal);
++
++- _mm256_store_si256((__m256i*)cPtr,cVal); // Store the results back into the C container
+++ _mm256_store_si256((__m256i*)cPtr,
+++ cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = oneEightPoints * 8;
++- for(;number < num_points; number++){
++- cVector[number] = aVector[number] | bVector[number];
++- }
+++ number = oneEightPoints * 8;
+++ for (; number < num_points; number++) {
+++ cVector[number] = aVector[number] | bVector[number];
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -160,35 +163,36 @@ volk_32i_x2_or_32i_a_avx2(int32_t* cVector, const int32_t* aVector,
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_32i_x2_or_32i_a_sse(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_or_32i_a_sse(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- float* cPtr = (float*)cVector;
++- const float* aPtr = (float*)aVector;
++- const float* bPtr = (float*)bVector;
+++ float* cPtr = (float*)cVector;
+++ const float* aPtr = (float*)aVector;
+++ const float* bPtr = (float*)bVector;
++
++- __m128 aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
++- aVal = _mm_load_ps(aPtr);
++- bVal = _mm_load_ps(bPtr);
+++ __m128 aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
+++ aVal = _mm_load_ps(aPtr);
+++ bVal = _mm_load_ps(bPtr);
++
++- cVal = _mm_or_ps(aVal, bVal);
+++ cVal = _mm_or_ps(aVal, bVal);
++
++- _mm_store_ps(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_ps(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- cVector[number] = aVector[number] | bVector[number];
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ cVector[number] = aVector[number] | bVector[number];
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -196,63 +200,67 @@ volk_32i_x2_or_32i_a_sse(int32_t* cVector, const int32_t* aVector,
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_32i_x2_or_32i_neon(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_or_32i_neon(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- int32_t* cPtr = cVector;
++- const int32_t* aPtr = aVector;
++- const int32_t* bPtr= bVector;
++- unsigned int number = 0;
++- unsigned int quarter_points = num_points / 4;
++-
++- int32x4_t a_val, b_val, c_val;
++-
++- for(number = 0; number < quarter_points; number++){
++- a_val = vld1q_s32(aPtr);
++- b_val = vld1q_s32(bPtr);
++- c_val = vorrq_s32(a_val, b_val);
++- vst1q_s32(cPtr, c_val);
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
++-
++- for(number = quarter_points * 4; number < num_points; number++){
++- *cPtr++ = (*aPtr++) | (*bPtr++);
++- }
+++ int32_t* cPtr = cVector;
+++ const int32_t* aPtr = aVector;
+++ const int32_t* bPtr = bVector;
+++ unsigned int number = 0;
+++ unsigned int quarter_points = num_points / 4;
+++
+++ int32x4_t a_val, b_val, c_val;
+++
+++ for (number = 0; number < quarter_points; number++) {
+++ a_val = vld1q_s32(aPtr);
+++ b_val = vld1q_s32(bPtr);
+++ c_val = vorrq_s32(a_val, b_val);
+++ vst1q_s32(cPtr, c_val);
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
+++
+++ for (number = quarter_points * 4; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) | (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32i_x2_or_32i_generic(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_or_32i_generic(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- int32_t* cPtr = cVector;
++- const int32_t* aPtr = aVector;
++- const int32_t* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *cPtr++ = (*aPtr++) | (*bPtr++);
++- }
+++ int32_t* cPtr = cVector;
+++ const int32_t* aPtr = aVector;
+++ const int32_t* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) | (*bPtr++);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++ #ifdef LV_HAVE_ORC
++-extern void
++-volk_32i_x2_or_32i_a_orc_impl(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points);
++-
++-static inline void
++-volk_32i_x2_or_32i_u_orc(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++extern void volk_32i_x2_or_32i_a_orc_impl(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points);
+++
+++static inline void volk_32i_x2_or_32i_u_orc(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- volk_32i_x2_or_32i_a_orc_impl(cVector, aVector, bVector, num_points);
+++ volk_32i_x2_or_32i_a_orc_impl(cVector, aVector, bVector, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++@@ -269,72 +277,75 @@ volk_32i_x2_or_32i_u_orc(int32_t* cVector, const int32_t* aVector,
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_32i_x2_or_32i_u_avx512f(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_or_32i_u_avx512f(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- int32_t* cPtr = (int32_t*)cVector;
++- const int32_t* aPtr = (int32_t*)aVector;
++- const int32_t* bPtr = (int32_t*)bVector;
+++ int32_t* cPtr = (int32_t*)cVector;
+++ const int32_t* aPtr = (int32_t*)aVector;
+++ const int32_t* bPtr = (int32_t*)bVector;
++
++- __m512i aVal, bVal, cVal;
++- for(;number < sixteenthPoints; number++){
+++ __m512i aVal, bVal, cVal;
+++ for (; number < sixteenthPoints; number++) {
++
++- aVal = _mm512_loadu_si512(aPtr);
++- bVal = _mm512_loadu_si512(bPtr);
+++ aVal = _mm512_loadu_si512(aPtr);
+++ bVal = _mm512_loadu_si512(bPtr);
++
++- cVal = _mm512_or_si512(aVal, bVal);
+++ cVal = _mm512_or_si512(aVal, bVal);
++
++- _mm512_storeu_si512(cPtr,cVal); // Store the results back into the C container
+++ _mm512_storeu_si512(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 16;
++- bPtr += 16;
++- cPtr += 16;
++- }
+++ aPtr += 16;
+++ bPtr += 16;
+++ cPtr += 16;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(;number < num_points; number++){
++- cVector[number] = aVector[number] | bVector[number];
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ cVector[number] = aVector[number] | bVector[number];
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_32i_x2_or_32i_u_avx2(int32_t* cVector, const int32_t* aVector,
++- const int32_t* bVector, unsigned int num_points)
+++static inline void volk_32i_x2_or_32i_u_avx2(int32_t* cVector,
+++ const int32_t* aVector,
+++ const int32_t* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int oneEightPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int oneEightPoints = num_points / 8;
++
++- int32_t* cPtr = cVector;
++- const int32_t* aPtr = aVector;
++- const int32_t* bPtr = bVector;
+++ int32_t* cPtr = cVector;
+++ const int32_t* aPtr = aVector;
+++ const int32_t* bPtr = bVector;
++
++- __m256i aVal, bVal, cVal;
++- for(;number < oneEightPoints; number++){
+++ __m256i aVal, bVal, cVal;
+++ for (; number < oneEightPoints; number++) {
++
++- aVal = _mm256_loadu_si256((__m256i*)aPtr);
++- bVal = _mm256_loadu_si256((__m256i*)bPtr);
+++ aVal = _mm256_loadu_si256((__m256i*)aPtr);
+++ bVal = _mm256_loadu_si256((__m256i*)bPtr);
++
++- cVal = _mm256_or_si256(aVal, bVal);
+++ cVal = _mm256_or_si256(aVal, bVal);
++
++- _mm256_storeu_si256((__m256i*)cPtr,cVal); // Store the results back into the C container
+++ _mm256_storeu_si256((__m256i*)cPtr,
+++ cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = oneEightPoints * 8;
++- for(;number < num_points; number++){
++- cVector[number] = aVector[number] | bVector[number];
++- }
+++ number = oneEightPoints * 8;
+++ for (; number < num_points; number++) {
+++ cVector[number] = aVector[number] | bVector[number];
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_32u_byteswap.h b/kernels/volk/volk_32u_byteswap.h
++index f5e6f11..185047c 100644
++--- a/kernels/volk/volk_32u_byteswap.h
+++++ b/kernels/volk/volk_32u_byteswap.h
++@@ -71,38 +71,42 @@
++
++ #if LV_HAVE_AVX2
++ #include <immintrin.h>
++-static inline void volk_32u_byteswap_u_avx2(uint32_t* intsToSwap, unsigned int num_points){
+++static inline void volk_32u_byteswap_u_avx2(uint32_t* intsToSwap, unsigned int num_points)
+++{
++
++- unsigned int number;
+++ unsigned int number;
++
++- const unsigned int nPerSet = 8;
++- const uint64_t nSets = num_points / nPerSet;
+++ const unsigned int nPerSet = 8;
+++ const uint64_t nSets = num_points / nPerSet;
++
++- uint32_t* inputPtr = intsToSwap;
+++ uint32_t* inputPtr = intsToSwap;
++
++- const uint8_t shuffleVector[32] = { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12, 19, 18, 17, 16, 23, 22, 21, 20, 27, 26, 25, 24, 31, 30, 29, 28 };
+++ const uint8_t shuffleVector[32] = { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9,
+++ 8, 15, 14, 13, 12, 19, 18, 17, 16, 23, 22,
+++ 21, 20, 27, 26, 25, 24, 31, 30, 29, 28 };
++
++- const __m256i myShuffle = _mm256_loadu_si256((__m256i*) &shuffleVector);
+++ const __m256i myShuffle = _mm256_loadu_si256((__m256i*)&shuffleVector);
++
++- for (number = 0 ;number < nSets; number++) {
+++ for (number = 0; number < nSets; number++) {
++
++- // Load the 32t values, increment inputPtr later since we're doing it in-place.
++- const __m256i input = _mm256_loadu_si256((__m256i*)inputPtr);
++- const __m256i output = _mm256_shuffle_epi8(input,myShuffle);
+++ // Load the 32t values, increment inputPtr later since we're doing it in-place.
+++ const __m256i input = _mm256_loadu_si256((__m256i*)inputPtr);
+++ const __m256i output = _mm256_shuffle_epi8(input, myShuffle);
++
++- // Store the results
++- _mm256_storeu_si256((__m256i*)inputPtr, output);
++- inputPtr += nPerSet;
++- }
++- _mm256_zeroupper();
++-
++- // Byteswap any remaining points:
++- for(number = nSets * nPerSet; number < num_points; number++){
++- uint32_t outputVal = *inputPtr;
++- outputVal = (((outputVal >> 24) & 0xff) | ((outputVal >> 8) & 0x0000ff00) | ((outputVal << 8) & 0x00ff0000) | ((outputVal << 24) & 0xff000000));
++- *inputPtr = outputVal;
++- inputPtr++;
++- }
+++ // Store the results
+++ _mm256_storeu_si256((__m256i*)inputPtr, output);
+++ inputPtr += nPerSet;
+++ }
+++ _mm256_zeroupper();
+++
+++ // Byteswap any remaining points:
+++ for (number = nSets * nPerSet; number < num_points; number++) {
+++ uint32_t outputVal = *inputPtr;
+++ outputVal = (((outputVal >> 24) & 0xff) | ((outputVal >> 8) & 0x0000ff00) |
+++ ((outputVal << 8) & 0x00ff0000) | ((outputVal << 24) & 0xff000000));
+++ *inputPtr = outputVal;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -110,42 +114,44 @@ static inline void volk_32u_byteswap_u_avx2(uint32_t* intsToSwap, unsigned int n
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_32u_byteswap_u_sse2(uint32_t* intsToSwap, unsigned int num_points){
++- unsigned int number = 0;
++-
++- uint32_t* inputPtr = intsToSwap;
++- __m128i input, byte1, byte2, byte3, byte4, output;
++- __m128i byte2mask = _mm_set1_epi32(0x00FF0000);
++- __m128i byte3mask = _mm_set1_epi32(0x0000FF00);
++-
++- const uint64_t quarterPoints = num_points / 4;
++- for(;number < quarterPoints; number++){
++- // Load the 32t values, increment inputPtr later since we're doing it in-place.
++- input = _mm_loadu_si128((__m128i*)inputPtr);
++- // Do the four shifts
++- byte1 = _mm_slli_epi32(input, 24);
++- byte2 = _mm_slli_epi32(input, 8);
++- byte3 = _mm_srli_epi32(input, 8);
++- byte4 = _mm_srli_epi32(input, 24);
++- // Or bytes together
++- output = _mm_or_si128(byte1, byte4);
++- byte2 = _mm_and_si128(byte2, byte2mask);
++- output = _mm_or_si128(output, byte2);
++- byte3 = _mm_and_si128(byte3, byte3mask);
++- output = _mm_or_si128(output, byte3);
++- // Store the results
++- _mm_storeu_si128((__m128i*)inputPtr, output);
++- inputPtr += 4;
++- }
++-
++- // Byteswap any remaining points:
++- number = quarterPoints*4;
++- for(; number < num_points; number++){
++- uint32_t outputVal = *inputPtr;
++- outputVal = (((outputVal >> 24) & 0xff) | ((outputVal >> 8) & 0x0000ff00) | ((outputVal << 8) & 0x00ff0000) | ((outputVal << 24) & 0xff000000));
++- *inputPtr = outputVal;
++- inputPtr++;
++- }
+++static inline void volk_32u_byteswap_u_sse2(uint32_t* intsToSwap, unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++
+++ uint32_t* inputPtr = intsToSwap;
+++ __m128i input, byte1, byte2, byte3, byte4, output;
+++ __m128i byte2mask = _mm_set1_epi32(0x00FF0000);
+++ __m128i byte3mask = _mm_set1_epi32(0x0000FF00);
+++
+++ const uint64_t quarterPoints = num_points / 4;
+++ for (; number < quarterPoints; number++) {
+++ // Load the 32t values, increment inputPtr later since we're doing it in-place.
+++ input = _mm_loadu_si128((__m128i*)inputPtr);
+++ // Do the four shifts
+++ byte1 = _mm_slli_epi32(input, 24);
+++ byte2 = _mm_slli_epi32(input, 8);
+++ byte3 = _mm_srli_epi32(input, 8);
+++ byte4 = _mm_srli_epi32(input, 24);
+++ // Or bytes together
+++ output = _mm_or_si128(byte1, byte4);
+++ byte2 = _mm_and_si128(byte2, byte2mask);
+++ output = _mm_or_si128(output, byte2);
+++ byte3 = _mm_and_si128(byte3, byte3mask);
+++ output = _mm_or_si128(output, byte3);
+++ // Store the results
+++ _mm_storeu_si128((__m128i*)inputPtr, output);
+++ inputPtr += 4;
+++ }
+++
+++ // Byteswap any remaining points:
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ uint32_t outputVal = *inputPtr;
+++ outputVal = (((outputVal >> 24) & 0xff) | ((outputVal >> 8) & 0x0000ff00) |
+++ ((outputVal << 8) & 0x00ff0000) | ((outputVal << 24) & 0xff000000));
+++ *inputPtr = outputVal;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++@@ -153,100 +159,106 @@ static inline void volk_32u_byteswap_u_sse2(uint32_t* intsToSwap, unsigned int n
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_32u_byteswap_neon(uint32_t* intsToSwap, unsigned int num_points){
++- uint32_t* inputPtr = intsToSwap;
++- unsigned int number = 0;
++- unsigned int n8points = num_points / 8;
++-
++- uint8x8x4_t input_table;
++- uint8x8_t int_lookup01, int_lookup23, int_lookup45, int_lookup67;
++- uint8x8_t swapped_int01, swapped_int23, swapped_int45, swapped_int67;
++-
++- /* these magic numbers are used as byte-indices in the LUT.
++- they are pre-computed to save time. A simple C program
++- can calculate them; for example for lookup01:
++- uint8_t chars[8] = {24, 16, 8, 0, 25, 17, 9, 1};
++- for(ii=0; ii < 8; ++ii) {
++- index += ((uint64_t)(*(chars+ii))) << (ii*8);
+++static inline void volk_32u_byteswap_neon(uint32_t* intsToSwap, unsigned int num_points)
+++{
+++ uint32_t* inputPtr = intsToSwap;
+++ unsigned int number = 0;
+++ unsigned int n8points = num_points / 8;
+++
+++ uint8x8x4_t input_table;
+++ uint8x8_t int_lookup01, int_lookup23, int_lookup45, int_lookup67;
+++ uint8x8_t swapped_int01, swapped_int23, swapped_int45, swapped_int67;
+++
+++ /* these magic numbers are used as byte-indices in the LUT.
+++ they are pre-computed to save time. A simple C program
+++ can calculate them; for example for lookup01:
+++ uint8_t chars[8] = {24, 16, 8, 0, 25, 17, 9, 1};
+++ for(ii=0; ii < 8; ++ii) {
+++ index += ((uint64_t)(*(chars+ii))) << (ii*8);
+++ }
+++ */
+++ int_lookup01 = vcreate_u8(74609667900706840);
+++ int_lookup23 = vcreate_u8(219290013576860186);
+++ int_lookup45 = vcreate_u8(363970359253013532);
+++ int_lookup67 = vcreate_u8(508650704929166878);
+++
+++ for (number = 0; number < n8points; ++number) {
+++ input_table = vld4_u8((uint8_t*)inputPtr);
+++ swapped_int01 = vtbl4_u8(input_table, int_lookup01);
+++ swapped_int23 = vtbl4_u8(input_table, int_lookup23);
+++ swapped_int45 = vtbl4_u8(input_table, int_lookup45);
+++ swapped_int67 = vtbl4_u8(input_table, int_lookup67);
+++ vst1_u8((uint8_t*)inputPtr, swapped_int01);
+++ vst1_u8((uint8_t*)(inputPtr + 2), swapped_int23);
+++ vst1_u8((uint8_t*)(inputPtr + 4), swapped_int45);
+++ vst1_u8((uint8_t*)(inputPtr + 6), swapped_int67);
+++
+++ inputPtr += 8;
+++ }
+++
+++ for (number = n8points * 8; number < num_points; ++number) {
+++ uint32_t output = *inputPtr;
+++ output = (((output >> 24) & 0xff) | ((output >> 8) & 0x0000ff00) |
+++ ((output << 8) & 0x00ff0000) | ((output << 24) & 0xff000000));
+++
+++ *inputPtr = output;
+++ inputPtr++;
++ }
++- */
++- int_lookup01 = vcreate_u8(74609667900706840);
++- int_lookup23 = vcreate_u8(219290013576860186);
++- int_lookup45 = vcreate_u8(363970359253013532);
++- int_lookup67 = vcreate_u8(508650704929166878);
++-
++- for(number = 0; number < n8points; ++number){
++- input_table = vld4_u8((uint8_t*) inputPtr);
++- swapped_int01 = vtbl4_u8(input_table, int_lookup01);
++- swapped_int23 = vtbl4_u8(input_table, int_lookup23);
++- swapped_int45 = vtbl4_u8(input_table, int_lookup45);
++- swapped_int67 = vtbl4_u8(input_table, int_lookup67);
++- vst1_u8((uint8_t*) inputPtr, swapped_int01);
++- vst1_u8((uint8_t*) (inputPtr+2), swapped_int23);
++- vst1_u8((uint8_t*) (inputPtr+4), swapped_int45);
++- vst1_u8((uint8_t*) (inputPtr+6), swapped_int67);
++-
++- inputPtr += 8;
++- }
++-
++- for(number = n8points * 8; number < num_points; ++number){
++- uint32_t output = *inputPtr;
++- output = (((output >> 24) & 0xff) | ((output >> 8) & 0x0000ff00) | ((output << 8) & 0x00ff0000) | ((output << 24) & 0xff000000));
++-
++- *inputPtr = output;
++- inputPtr++;
++- }
++ }
++ #endif /* LV_HAVE_NEON */
++
++ #ifdef LV_HAVE_NEONV8
++ #include <arm_neon.h>
++
++-static inline void volk_32u_byteswap_neonv8(uint32_t* intsToSwap, unsigned int num_points){
++- uint32_t* inputPtr = (uint32_t*)intsToSwap;
++- const unsigned int n8points = num_points / 8;
++- uint8x16_t input;
++- uint8x16_t idx = { 3,2,1,0, 7,6,5,4, 11,10,9,8, 15,14,13,12 };
++-
++- unsigned int number = 0;
++- for(number = 0; number < n8points; ++number){
++- __VOLK_PREFETCH(inputPtr+8);
++- input = vld1q_u8((uint8_t*) inputPtr);
++- input = vqtbl1q_u8(input, idx);
++- vst1q_u8((uint8_t*) inputPtr, input);
++- inputPtr += 4;
++-
++- input = vld1q_u8((uint8_t*) inputPtr);
++- input = vqtbl1q_u8(input, idx);
++- vst1q_u8((uint8_t*) inputPtr, input);
++- inputPtr += 4;
++- }
++-
++- for(number = n8points * 8; number < num_points; ++number){
++- uint32_t output = *inputPtr;
+++static inline void volk_32u_byteswap_neonv8(uint32_t* intsToSwap, unsigned int num_points)
+++{
+++ uint32_t* inputPtr = (uint32_t*)intsToSwap;
+++ const unsigned int n8points = num_points / 8;
+++ uint8x16_t input;
+++ uint8x16_t idx = { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
+++
+++ unsigned int number = 0;
+++ for (number = 0; number < n8points; ++number) {
+++ __VOLK_PREFETCH(inputPtr + 8);
+++ input = vld1q_u8((uint8_t*)inputPtr);
+++ input = vqtbl1q_u8(input, idx);
+++ vst1q_u8((uint8_t*)inputPtr, input);
+++ inputPtr += 4;
+++
+++ input = vld1q_u8((uint8_t*)inputPtr);
+++ input = vqtbl1q_u8(input, idx);
+++ vst1q_u8((uint8_t*)inputPtr, input);
+++ inputPtr += 4;
+++ }
++
++- output = (((output >> 24) & 0xff) | ((output >> 8) & 0x0000ff00) | ((output << 8) & 0x00ff0000) | ((output << 24) & 0xff000000));
+++ for (number = n8points * 8; number < num_points; ++number) {
+++ uint32_t output = *inputPtr;
++
++- *inputPtr++ = output;
++- }
+++ output = (((output >> 24) & 0xff) | ((output >> 8) & 0x0000ff00) |
+++ ((output << 8) & 0x00ff0000) | ((output << 24) & 0xff000000));
++
+++ *inputPtr++ = output;
+++ }
++ }
++ #endif /* LV_HAVE_NEONV8 */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32u_byteswap_generic(uint32_t* intsToSwap, unsigned int num_points){
++- uint32_t* inputPtr = intsToSwap;
+++static inline void volk_32u_byteswap_generic(uint32_t* intsToSwap,
+++ unsigned int num_points)
+++{
+++ uint32_t* inputPtr = intsToSwap;
++
++- unsigned int point;
++- for(point = 0; point < num_points; point++){
++- uint32_t output = *inputPtr;
++- output = (((output >> 24) & 0xff) | ((output >> 8) & 0x0000ff00) | ((output << 8) & 0x00ff0000) | ((output << 24) & 0xff000000));
+++ unsigned int point;
+++ for (point = 0; point < num_points; point++) {
+++ uint32_t output = *inputPtr;
+++ output = (((output >> 24) & 0xff) | ((output >> 8) & 0x0000ff00) |
+++ ((output << 8) & 0x00ff0000) | ((output << 24) & 0xff000000));
++
++- *inputPtr = output;
++- inputPtr++;
++- }
+++ *inputPtr = output;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -261,38 +273,42 @@ static inline void volk_32u_byteswap_generic(uint32_t* intsToSwap, unsigned int
++
++ #if LV_HAVE_AVX2
++ #include <immintrin.h>
++-static inline void volk_32u_byteswap_a_avx2(uint32_t* intsToSwap, unsigned int num_points){
+++static inline void volk_32u_byteswap_a_avx2(uint32_t* intsToSwap, unsigned int num_points)
+++{
++
++- unsigned int number;
+++ unsigned int number;
++
++- const unsigned int nPerSet = 8;
++- const uint64_t nSets = num_points / nPerSet;
+++ const unsigned int nPerSet = 8;
+++ const uint64_t nSets = num_points / nPerSet;
++
++- uint32_t* inputPtr = intsToSwap;
+++ uint32_t* inputPtr = intsToSwap;
++
++- const uint8_t shuffleVector[32] = { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12, 19, 18, 17, 16, 23, 22, 21, 20, 27, 26, 25, 24, 31, 30, 29, 28 };
+++ const uint8_t shuffleVector[32] = { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9,
+++ 8, 15, 14, 13, 12, 19, 18, 17, 16, 23, 22,
+++ 21, 20, 27, 26, 25, 24, 31, 30, 29, 28 };
++
++- const __m256i myShuffle = _mm256_loadu_si256((__m256i*) &shuffleVector);
+++ const __m256i myShuffle = _mm256_loadu_si256((__m256i*)&shuffleVector);
++
++- for (number = 0 ;number < nSets; number++) {
+++ for (number = 0; number < nSets; number++) {
++
++- // Load the 32t values, increment inputPtr later since we're doing it in-place.
++- const __m256i input = _mm256_load_si256((__m256i*)inputPtr);
++- const __m256i output = _mm256_shuffle_epi8(input,myShuffle);
+++ // Load the 32t values, increment inputPtr later since we're doing it in-place.
+++ const __m256i input = _mm256_load_si256((__m256i*)inputPtr);
+++ const __m256i output = _mm256_shuffle_epi8(input, myShuffle);
++
++- // Store the results
++- _mm256_store_si256((__m256i*)inputPtr, output);
++- inputPtr += nPerSet;
++- }
++- _mm256_zeroupper();
++-
++- // Byteswap any remaining points:
++- for(number = nSets * nPerSet; number < num_points; number++){
++- uint32_t outputVal = *inputPtr;
++- outputVal = (((outputVal >> 24) & 0xff) | ((outputVal >> 8) & 0x0000ff00) | ((outputVal << 8) & 0x00ff0000) | ((outputVal << 24) & 0xff000000));
++- *inputPtr = outputVal;
++- inputPtr++;
++- }
+++ // Store the results
+++ _mm256_store_si256((__m256i*)inputPtr, output);
+++ inputPtr += nPerSet;
+++ }
+++ _mm256_zeroupper();
+++
+++ // Byteswap any remaining points:
+++ for (number = nSets * nPerSet; number < num_points; number++) {
+++ uint32_t outputVal = *inputPtr;
+++ outputVal = (((outputVal >> 24) & 0xff) | ((outputVal >> 8) & 0x0000ff00) |
+++ ((outputVal << 8) & 0x00ff0000) | ((outputVal << 24) & 0xff000000));
+++ *inputPtr = outputVal;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -301,63 +317,66 @@ static inline void volk_32u_byteswap_a_avx2(uint32_t* intsToSwap, unsigned int n
++ #include <emmintrin.h>
++
++
++-static inline void volk_32u_byteswap_a_sse2(uint32_t* intsToSwap, unsigned int num_points){
++- unsigned int number = 0;
++-
++- uint32_t* inputPtr = intsToSwap;
++- __m128i input, byte1, byte2, byte3, byte4, output;
++- __m128i byte2mask = _mm_set1_epi32(0x00FF0000);
++- __m128i byte3mask = _mm_set1_epi32(0x0000FF00);
++-
++- const uint64_t quarterPoints = num_points / 4;
++- for(;number < quarterPoints; number++){
++- // Load the 32t values, increment inputPtr later since we're doing it in-place.
++- input = _mm_load_si128((__m128i*)inputPtr);
++- // Do the four shifts
++- byte1 = _mm_slli_epi32(input, 24);
++- byte2 = _mm_slli_epi32(input, 8);
++- byte3 = _mm_srli_epi32(input, 8);
++- byte4 = _mm_srli_epi32(input, 24);
++- // Or bytes together
++- output = _mm_or_si128(byte1, byte4);
++- byte2 = _mm_and_si128(byte2, byte2mask);
++- output = _mm_or_si128(output, byte2);
++- byte3 = _mm_and_si128(byte3, byte3mask);
++- output = _mm_or_si128(output, byte3);
++- // Store the results
++- _mm_store_si128((__m128i*)inputPtr, output);
++- inputPtr += 4;
++- }
++-
++- // Byteswap any remaining points:
++- number = quarterPoints*4;
++- for(; number < num_points; number++){
++- uint32_t outputVal = *inputPtr;
++- outputVal = (((outputVal >> 24) & 0xff) | ((outputVal >> 8) & 0x0000ff00) | ((outputVal << 8) & 0x00ff0000) | ((outputVal << 24) & 0xff000000));
++- *inputPtr = outputVal;
++- inputPtr++;
++- }
+++static inline void volk_32u_byteswap_a_sse2(uint32_t* intsToSwap, unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++
+++ uint32_t* inputPtr = intsToSwap;
+++ __m128i input, byte1, byte2, byte3, byte4, output;
+++ __m128i byte2mask = _mm_set1_epi32(0x00FF0000);
+++ __m128i byte3mask = _mm_set1_epi32(0x0000FF00);
+++
+++ const uint64_t quarterPoints = num_points / 4;
+++ for (; number < quarterPoints; number++) {
+++ // Load the 32t values, increment inputPtr later since we're doing it in-place.
+++ input = _mm_load_si128((__m128i*)inputPtr);
+++ // Do the four shifts
+++ byte1 = _mm_slli_epi32(input, 24);
+++ byte2 = _mm_slli_epi32(input, 8);
+++ byte3 = _mm_srli_epi32(input, 8);
+++ byte4 = _mm_srli_epi32(input, 24);
+++ // Or bytes together
+++ output = _mm_or_si128(byte1, byte4);
+++ byte2 = _mm_and_si128(byte2, byte2mask);
+++ output = _mm_or_si128(output, byte2);
+++ byte3 = _mm_and_si128(byte3, byte3mask);
+++ output = _mm_or_si128(output, byte3);
+++ // Store the results
+++ _mm_store_si128((__m128i*)inputPtr, output);
+++ inputPtr += 4;
+++ }
+++
+++ // Byteswap any remaining points:
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ uint32_t outputVal = *inputPtr;
+++ outputVal = (((outputVal >> 24) & 0xff) | ((outputVal >> 8) & 0x0000ff00) |
+++ ((outputVal << 8) & 0x00ff0000) | ((outputVal << 24) & 0xff000000));
+++ *inputPtr = outputVal;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_32u_byteswap_a_generic(uint32_t* intsToSwap, unsigned int num_points){
++- uint32_t* inputPtr = intsToSwap;
+++static inline void volk_32u_byteswap_a_generic(uint32_t* intsToSwap,
+++ unsigned int num_points)
+++{
+++ uint32_t* inputPtr = intsToSwap;
++
++- unsigned int point;
++- for(point = 0; point < num_points; point++){
++- uint32_t output = *inputPtr;
++- output = (((output >> 24) & 0xff) | ((output >> 8) & 0x0000ff00) | ((output << 8) & 0x00ff0000) | ((output << 24) & 0xff000000));
+++ unsigned int point;
+++ for (point = 0; point < num_points; point++) {
+++ uint32_t output = *inputPtr;
+++ output = (((output >> 24) & 0xff) | ((output >> 8) & 0x0000ff00) |
+++ ((output << 8) & 0x00ff0000) | ((output << 24) & 0xff000000));
++
++- *inputPtr = output;
++- inputPtr++;
++- }
+++ *inputPtr = output;
+++ inputPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++-
++ #endif /* INCLUDED_volk_32u_byteswap_a_H */
++diff --git a/kernels/volk/volk_32u_byteswappuppet_32u.h b/kernels/volk/volk_32u_byteswappuppet_32u.h
++index c33a5fc..ca5ca17 100644
++--- a/kernels/volk/volk_32u_byteswappuppet_32u.h
+++++ b/kernels/volk/volk_32u_byteswappuppet_32u.h
++@@ -1,70 +1,84 @@
++ #ifndef INCLUDED_volk_32u_byteswappuppet_32u_H
++ #define INCLUDED_volk_32u_byteswappuppet_32u_H
++
++-#include <volk/volk_32u_byteswap.h>
++ #include <stdint.h>
++ #include <string.h>
+++#include <volk/volk_32u_byteswap.h>
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void volk_32u_byteswappuppet_32u_generic(uint32_t*output, uint32_t* intsToSwap, unsigned int num_points){
+++static inline void volk_32u_byteswappuppet_32u_generic(uint32_t* output,
+++ uint32_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_32u_byteswap_generic((uint32_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint32_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_NEON
++-static inline void volk_32u_byteswappuppet_32u_neon(uint32_t*output, uint32_t* intsToSwap, unsigned int num_points){
+++static inline void volk_32u_byteswappuppet_32u_neon(uint32_t* output,
+++ uint32_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_32u_byteswap_neon((uint32_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint32_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_NEONV8
++-static inline void volk_32u_byteswappuppet_32u_neonv8(uint32_t*output, uint32_t* intsToSwap, unsigned int num_points){
+++static inline void volk_32u_byteswappuppet_32u_neonv8(uint32_t* output,
+++ uint32_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_32u_byteswap_neonv8((uint32_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint32_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_SSE2
++-static inline void volk_32u_byteswappuppet_32u_u_sse2(uint32_t *output, uint32_t* intsToSwap, unsigned int num_points){
+++static inline void volk_32u_byteswappuppet_32u_u_sse2(uint32_t* output,
+++ uint32_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_32u_byteswap_u_sse2((uint32_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint32_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_SSE2
++-static inline void volk_32u_byteswappuppet_32u_a_sse2(uint32_t* output, uint32_t* intsToSwap, unsigned int num_points){
+++static inline void volk_32u_byteswappuppet_32u_a_sse2(uint32_t* output,
+++ uint32_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_32u_byteswap_a_sse2((uint32_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint32_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_AVX2
++-static inline void volk_32u_byteswappuppet_32u_u_avx2(uint32_t* output, uint32_t* intsToSwap, unsigned int num_points){
+++static inline void volk_32u_byteswappuppet_32u_u_avx2(uint32_t* output,
+++ uint32_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_32u_byteswap_u_avx2((uint32_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint32_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_AVX2
++-static inline void volk_32u_byteswappuppet_32u_a_avx2(uint32_t* output, uint32_t* intsToSwap, unsigned int num_points){
+++static inline void volk_32u_byteswappuppet_32u_a_avx2(uint32_t* output,
+++ uint32_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_32u_byteswap_a_avx2((uint32_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint32_t));
++-
++ }
++ #endif
++
++diff --git a/kernels/volk/volk_32u_popcnt.h b/kernels/volk/volk_32u_popcnt.h
++index 7aa4d43..f6f0c10 100644
++--- a/kernels/volk/volk_32u_popcnt.h
+++++ b/kernels/volk/volk_32u_popcnt.h
++@@ -56,24 +56,23 @@
++ #ifndef INCLUDED_VOLK_32u_POPCNT_A16_H
++ #define INCLUDED_VOLK_32u_POPCNT_A16_H
++
++-#include <stdio.h>
++ #include <inttypes.h>
+++#include <stdio.h>
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_32u_popcnt_generic(uint32_t* ret, const uint32_t value)
+++static inline void volk_32u_popcnt_generic(uint32_t* ret, const uint32_t value)
++ {
++- // This is faster than a lookup table
++- uint32_t retVal = value;
+++ // This is faster than a lookup table
+++ uint32_t retVal = value;
++
++- retVal = (retVal & 0x55555555) + (retVal >> 1 & 0x55555555);
++- retVal = (retVal & 0x33333333) + (retVal >> 2 & 0x33333333);
++- retVal = (retVal + (retVal >> 4)) & 0x0F0F0F0F;
++- retVal = (retVal + (retVal >> 8));
++- retVal = (retVal + (retVal >> 16)) & 0x0000003F;
+++ retVal = (retVal & 0x55555555) + (retVal >> 1 & 0x55555555);
+++ retVal = (retVal & 0x33333333) + (retVal >> 2 & 0x33333333);
+++ retVal = (retVal + (retVal >> 4)) & 0x0F0F0F0F;
+++ retVal = (retVal + (retVal >> 8));
+++ retVal = (retVal + (retVal >> 16)) & 0x0000003F;
++
++- *ret = retVal;
+++ *ret = retVal;
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -83,10 +82,9 @@ volk_32u_popcnt_generic(uint32_t* ret, const uint32_t value)
++
++ #include <nmmintrin.h>
++
++-static inline void
++-volk_32u_popcnt_a_sse4_2(uint32_t* ret, const uint32_t value)
+++static inline void volk_32u_popcnt_a_sse4_2(uint32_t* ret, const uint32_t value)
++ {
++- *ret = _mm_popcnt_u32(value);
+++ *ret = _mm_popcnt_u32(value);
++ }
++
++ #endif /*LV_HAVE_SSE4_2*/
++diff --git a/kernels/volk/volk_32u_popcntpuppet_32u.h b/kernels/volk/volk_32u_popcntpuppet_32u.h
++index d5edd35..c0389cc 100644
++--- a/kernels/volk/volk_32u_popcntpuppet_32u.h
+++++ b/kernels/volk/volk_32u_popcntpuppet_32u.h
++@@ -27,19 +27,25 @@
++ #include <volk/volk_32u_popcnt.h>
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void volk_32u_popcntpuppet_32u_generic(uint32_t* outVector, const uint32_t* inVector, unsigned int num_points){
+++static inline void volk_32u_popcntpuppet_32u_generic(uint32_t* outVector,
+++ const uint32_t* inVector,
+++ unsigned int num_points)
+++{
++ unsigned int ii;
++- for(ii=0; ii < num_points; ++ii) {
++- volk_32u_popcnt_generic(outVector+ii, *(inVector+ii) );
+++ for (ii = 0; ii < num_points; ++ii) {
+++ volk_32u_popcnt_generic(outVector + ii, *(inVector + ii));
++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_SSE4_2
++-static inline void volk_32u_popcntpuppet_32u_a_sse4_2(uint32_t* outVector, const uint32_t* inVector, unsigned int num_points){
+++static inline void volk_32u_popcntpuppet_32u_a_sse4_2(uint32_t* outVector,
+++ const uint32_t* inVector,
+++ unsigned int num_points)
+++{
++ unsigned int ii;
++- for(ii=0; ii < num_points; ++ii) {
++- volk_32u_popcnt_a_sse4_2(outVector+ii, *(inVector+ii) );
+++ for (ii = 0; ii < num_points; ++ii) {
+++ volk_32u_popcnt_a_sse4_2(outVector + ii, *(inVector + ii));
++ }
++ }
++ #endif /* LV_HAVE_SSE4_2 */
++diff --git a/kernels/volk/volk_32u_reverse_32u.h b/kernels/volk/volk_32u_reverse_32u.h
++index b670b13..aff0a9e 100644
++--- a/kernels/volk/volk_32u_reverse_32u.h
+++++ b/kernels/volk/volk_32u_reverse_32u.h
++@@ -24,7 +24,8 @@
++ * \b bit reversal of the input 32 bit word
++
++ * <b>Dispatcher Prototype</b>
++- * \code volk_32u_reverse_32u(uint32_t *outputVector, uint32_t *inputVector; unsigned int num_points);
+++ * \code volk_32u_reverse_32u(uint32_t *outputVector, uint32_t *inputVector; unsigned int
+++ num_points);
++ * \endcode
++ *
++ * \b Inputs
++@@ -32,338 +33,344 @@
++ * \li num_points The number of data points.
++ *
++ * \b Outputs
++- * \li outputVector: The vector where the results will be stored, which is the bit-reversed input
+++ * \li outputVector: The vector where the results will be stored, which is the
+++ bit-reversed input
++ *
++ * \endcode
++ */
++ #ifndef INCLUDED_VOLK_32u_REVERSE_32u_U_H
++ struct dword_split {
++- int b00: 1;
++- int b01: 1;
++- int b02: 1;
++- int b03: 1;
++- int b04: 1;
++- int b05: 1;
++- int b06: 1;
++- int b07: 1;
++- int b08: 1;
++- int b09: 1;
++- int b10: 1;
++- int b11: 1;
++- int b12: 1;
++- int b13: 1;
++- int b14: 1;
++- int b15: 1;
++- int b16: 1;
++- int b17: 1;
++- int b18: 1;
++- int b19: 1;
++- int b20: 1;
++- int b21: 1;
++- int b22: 1;
++- int b23: 1;
++- int b24: 1;
++- int b25: 1;
++- int b26: 1;
++- int b27: 1;
++- int b28: 1;
++- int b29: 1;
++- int b30: 1;
++- int b31: 1;
+++ int b00 : 1;
+++ int b01 : 1;
+++ int b02 : 1;
+++ int b03 : 1;
+++ int b04 : 1;
+++ int b05 : 1;
+++ int b06 : 1;
+++ int b07 : 1;
+++ int b08 : 1;
+++ int b09 : 1;
+++ int b10 : 1;
+++ int b11 : 1;
+++ int b12 : 1;
+++ int b13 : 1;
+++ int b14 : 1;
+++ int b15 : 1;
+++ int b16 : 1;
+++ int b17 : 1;
+++ int b18 : 1;
+++ int b19 : 1;
+++ int b20 : 1;
+++ int b21 : 1;
+++ int b22 : 1;
+++ int b23 : 1;
+++ int b24 : 1;
+++ int b25 : 1;
+++ int b26 : 1;
+++ int b27 : 1;
+++ int b28 : 1;
+++ int b29 : 1;
+++ int b30 : 1;
+++ int b31 : 1;
++ };
++ struct char_split {
++- uint8_t b00: 1;
++- uint8_t b01: 1;
++- uint8_t b02: 1;
++- uint8_t b03: 1;
++- uint8_t b04: 1;
++- uint8_t b05: 1;
++- uint8_t b06: 1;
++- uint8_t b07: 1;
+++ uint8_t b00 : 1;
+++ uint8_t b01 : 1;
+++ uint8_t b02 : 1;
+++ uint8_t b03 : 1;
+++ uint8_t b04 : 1;
+++ uint8_t b05 : 1;
+++ uint8_t b06 : 1;
+++ uint8_t b07 : 1;
++ };
++
++-//Idea from "Bit Twiddling Hacks", which dedicates this method to public domain
++-//http://graphics.stanford.edu/~seander/bithacks.html#BitReverseTable
+++// Idea from "Bit Twiddling Hacks", which dedicates this method to public domain
+++// http://graphics.stanford.edu/~seander/bithacks.html#BitReverseTable
++ static const unsigned char BitReverseTable256[] = {
++- 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30,
++- 0xB0, 0x70, 0xF0, 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98,
++- 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64,
++- 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, 0x0C, 0x8C, 0x4C, 0xCC,
++- 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, 0x02,
++- 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2,
++- 0x72, 0xF2, 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A,
++- 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
++- 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, 0x0E, 0x8E, 0x4E, 0xCE, 0x2E,
++- 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, 0x01, 0x81,
++- 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71,
++- 0xF1, 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9,
++- 0x39, 0xB9, 0x79, 0xF9, 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15,
++- 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD,
++- 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, 0x03, 0x83, 0x43,
++- 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
++- 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B,
++- 0xBB, 0x7B, 0xFB, 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97,
++- 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F,
++- 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
+++ 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0,
+++ 0x70, 0xF0, 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8,
+++ 0x38, 0xB8, 0x78, 0xF8, 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94,
+++ 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
+++ 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2,
+++ 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, 0x0A, 0x8A, 0x4A, 0xCA,
+++ 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, 0x06, 0x86,
+++ 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
+++ 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE,
+++ 0x7E, 0xFE, 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1,
+++ 0x31, 0xB1, 0x71, 0xF1, 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99,
+++ 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
+++ 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD,
+++ 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, 0x03, 0x83, 0x43, 0xC3,
+++ 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, 0x0B, 0x8B,
+++ 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
+++ 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7,
+++ 0x77, 0xF7, 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF,
+++ 0x3F, 0xBF, 0x7F, 0xFF
++ };
++ #ifdef LV_HAVE_GENERIC
++-static inline void volk_32u_reverse_32u_dword_shuffle(uint32_t* out, const uint32_t* in,
++- unsigned int num_points)
+++static inline void volk_32u_reverse_32u_dword_shuffle(uint32_t* out,
+++ const uint32_t* in,
+++ unsigned int num_points)
++ {
++- const struct dword_split *in_ptr = (const struct dword_split*)in;
++- struct dword_split * out_ptr = (struct dword_split*)out;
++- unsigned int number = 0;
++- for(; number < num_points; ++number){
++- out_ptr->b00 = in_ptr->b31;
++- out_ptr->b01 = in_ptr->b30;
++- out_ptr->b02 = in_ptr->b29;
++- out_ptr->b03 = in_ptr->b28;
++- out_ptr->b04 = in_ptr->b27;
++- out_ptr->b05 = in_ptr->b26;
++- out_ptr->b06 = in_ptr->b25;
++- out_ptr->b07 = in_ptr->b24;
++- out_ptr->b08 = in_ptr->b23;
++- out_ptr->b09 = in_ptr->b22;
++- out_ptr->b10 = in_ptr->b21;
++- out_ptr->b11 = in_ptr->b20;
++- out_ptr->b12 = in_ptr->b19;
++- out_ptr->b13 = in_ptr->b18;
++- out_ptr->b14 = in_ptr->b17;
++- out_ptr->b15 = in_ptr->b16;
++- out_ptr->b16 = in_ptr->b15;
++- out_ptr->b17 = in_ptr->b14;
++- out_ptr->b18 = in_ptr->b13;
++- out_ptr->b19 = in_ptr->b12;
++- out_ptr->b20 = in_ptr->b11;
++- out_ptr->b21 = in_ptr->b10;
++- out_ptr->b22 = in_ptr->b09;
++- out_ptr->b23 = in_ptr->b08;
++- out_ptr->b24 = in_ptr->b07;
++- out_ptr->b25 = in_ptr->b06;
++- out_ptr->b26 = in_ptr->b05;
++- out_ptr->b27 = in_ptr->b04;
++- out_ptr->b28 = in_ptr->b03;
++- out_ptr->b29 = in_ptr->b02;
++- out_ptr->b30 = in_ptr->b01;
++- out_ptr->b31 = in_ptr->b00;
++- ++in_ptr;
++- ++out_ptr;
++- }
+++ const struct dword_split* in_ptr = (const struct dword_split*)in;
+++ struct dword_split* out_ptr = (struct dword_split*)out;
+++ unsigned int number = 0;
+++ for (; number < num_points; ++number) {
+++ out_ptr->b00 = in_ptr->b31;
+++ out_ptr->b01 = in_ptr->b30;
+++ out_ptr->b02 = in_ptr->b29;
+++ out_ptr->b03 = in_ptr->b28;
+++ out_ptr->b04 = in_ptr->b27;
+++ out_ptr->b05 = in_ptr->b26;
+++ out_ptr->b06 = in_ptr->b25;
+++ out_ptr->b07 = in_ptr->b24;
+++ out_ptr->b08 = in_ptr->b23;
+++ out_ptr->b09 = in_ptr->b22;
+++ out_ptr->b10 = in_ptr->b21;
+++ out_ptr->b11 = in_ptr->b20;
+++ out_ptr->b12 = in_ptr->b19;
+++ out_ptr->b13 = in_ptr->b18;
+++ out_ptr->b14 = in_ptr->b17;
+++ out_ptr->b15 = in_ptr->b16;
+++ out_ptr->b16 = in_ptr->b15;
+++ out_ptr->b17 = in_ptr->b14;
+++ out_ptr->b18 = in_ptr->b13;
+++ out_ptr->b19 = in_ptr->b12;
+++ out_ptr->b20 = in_ptr->b11;
+++ out_ptr->b21 = in_ptr->b10;
+++ out_ptr->b22 = in_ptr->b09;
+++ out_ptr->b23 = in_ptr->b08;
+++ out_ptr->b24 = in_ptr->b07;
+++ out_ptr->b25 = in_ptr->b06;
+++ out_ptr->b26 = in_ptr->b05;
+++ out_ptr->b27 = in_ptr->b04;
+++ out_ptr->b28 = in_ptr->b03;
+++ out_ptr->b29 = in_ptr->b02;
+++ out_ptr->b30 = in_ptr->b01;
+++ out_ptr->b31 = in_ptr->b00;
+++ ++in_ptr;
+++ ++out_ptr;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void volk_32u_reverse_32u_byte_shuffle(uint32_t* out, const uint32_t* in,
++- unsigned int num_points)
+++static inline void volk_32u_reverse_32u_byte_shuffle(uint32_t* out,
+++ const uint32_t* in,
+++ unsigned int num_points)
++ {
++- const uint32_t *in_ptr = in;
++- uint32_t *out_ptr = out;
++- unsigned int number = 0;
++- for(; number < num_points; ++number){
++- const struct char_split *in8 = (const struct char_split*)in_ptr;
++- struct char_split *out8 = (struct char_split*)out_ptr;
+++ const uint32_t* in_ptr = in;
+++ uint32_t* out_ptr = out;
+++ unsigned int number = 0;
+++ for (; number < num_points; ++number) {
+++ const struct char_split* in8 = (const struct char_split*)in_ptr;
+++ struct char_split* out8 = (struct char_split*)out_ptr;
++
++- out8[3].b00 = in8[0].b07;
++- out8[3].b01 = in8[0].b06;
++- out8[3].b02 = in8[0].b05;
++- out8[3].b03 = in8[0].b04;
++- out8[3].b04 = in8[0].b03;
++- out8[3].b05 = in8[0].b02;
++- out8[3].b06 = in8[0].b01;
++- out8[3].b07 = in8[0].b00;
+++ out8[3].b00 = in8[0].b07;
+++ out8[3].b01 = in8[0].b06;
+++ out8[3].b02 = in8[0].b05;
+++ out8[3].b03 = in8[0].b04;
+++ out8[3].b04 = in8[0].b03;
+++ out8[3].b05 = in8[0].b02;
+++ out8[3].b06 = in8[0].b01;
+++ out8[3].b07 = in8[0].b00;
++
++- out8[2].b00 = in8[1].b07;
++- out8[2].b01 = in8[1].b06;
++- out8[2].b02 = in8[1].b05;
++- out8[2].b03 = in8[1].b04;
++- out8[2].b04 = in8[1].b03;
++- out8[2].b05 = in8[1].b02;
++- out8[2].b06 = in8[1].b01;
++- out8[2].b07 = in8[1].b00;
+++ out8[2].b00 = in8[1].b07;
+++ out8[2].b01 = in8[1].b06;
+++ out8[2].b02 = in8[1].b05;
+++ out8[2].b03 = in8[1].b04;
+++ out8[2].b04 = in8[1].b03;
+++ out8[2].b05 = in8[1].b02;
+++ out8[2].b06 = in8[1].b01;
+++ out8[2].b07 = in8[1].b00;
++
++- out8[1].b00 = in8[2].b07;
++- out8[1].b01 = in8[2].b06;
++- out8[1].b02 = in8[2].b05;
++- out8[1].b03 = in8[2].b04;
++- out8[1].b04 = in8[2].b03;
++- out8[1].b05 = in8[2].b02;
++- out8[1].b06 = in8[2].b01;
++- out8[1].b07 = in8[2].b00;
+++ out8[1].b00 = in8[2].b07;
+++ out8[1].b01 = in8[2].b06;
+++ out8[1].b02 = in8[2].b05;
+++ out8[1].b03 = in8[2].b04;
+++ out8[1].b04 = in8[2].b03;
+++ out8[1].b05 = in8[2].b02;
+++ out8[1].b06 = in8[2].b01;
+++ out8[1].b07 = in8[2].b00;
++
++- out8[0].b00 = in8[3].b07;
++- out8[0].b01 = in8[3].b06;
++- out8[0].b02 = in8[3].b05;
++- out8[0].b03 = in8[3].b04;
++- out8[0].b04 = in8[3].b03;
++- out8[0].b05 = in8[3].b02;
++- out8[0].b06 = in8[3].b01;
++- out8[0].b07 = in8[3].b00;
++- ++in_ptr;
++- ++out_ptr;
++- }
+++ out8[0].b00 = in8[3].b07;
+++ out8[0].b01 = in8[3].b06;
+++ out8[0].b02 = in8[3].b05;
+++ out8[0].b03 = in8[3].b04;
+++ out8[0].b04 = in8[3].b03;
+++ out8[0].b05 = in8[3].b02;
+++ out8[0].b06 = in8[3].b01;
+++ out8[0].b07 = in8[3].b00;
+++ ++in_ptr;
+++ ++out_ptr;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++-//Idea from "Bit Twiddling Hacks", which dedicates this method to public domain
++-//http://graphics.stanford.edu/~seander/bithacks.html#BitReverseTable
+++// Idea from "Bit Twiddling Hacks", which dedicates this method to public domain
+++// http://graphics.stanford.edu/~seander/bithacks.html#BitReverseTable
++ #ifdef LV_HAVE_GENERIC
++-static inline void volk_32u_reverse_32u_lut(uint32_t* out, const uint32_t* in,
++- unsigned int num_points)
+++static inline void
+++volk_32u_reverse_32u_lut(uint32_t* out, const uint32_t* in, unsigned int num_points)
++ {
++- const uint32_t *in_ptr = in;
++- uint32_t *out_ptr = out;
++- unsigned int number = 0;
++- for(; number < num_points; ++number){
++- *out_ptr =
++- (BitReverseTable256[*in_ptr & 0xff] << 24) |
++- (BitReverseTable256[(*in_ptr >> 8) & 0xff] << 16) |
++- (BitReverseTable256[(*in_ptr >> 16) & 0xff] << 8) |
++- (BitReverseTable256[(*in_ptr >> 24) & 0xff]);
++- ++in_ptr;
++- ++out_ptr;
++- }
+++ const uint32_t* in_ptr = in;
+++ uint32_t* out_ptr = out;
+++ unsigned int number = 0;
+++ for (; number < num_points; ++number) {
+++ *out_ptr = (BitReverseTable256[*in_ptr & 0xff] << 24) |
+++ (BitReverseTable256[(*in_ptr >> 8) & 0xff] << 16) |
+++ (BitReverseTable256[(*in_ptr >> 16) & 0xff] << 8) |
+++ (BitReverseTable256[(*in_ptr >> 24) & 0xff]);
+++ ++in_ptr;
+++ ++out_ptr;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++-//Single-Byte code from "Bit Twiddling Hacks", which dedicates this method to public domain
++-//http://graphics.stanford.edu/~seander/bithacks.html#ReverseByteWith64Bits
+++// Single-Byte code from "Bit Twiddling Hacks", which dedicates this method to public
+++// domain http://graphics.stanford.edu/~seander/bithacks.html#ReverseByteWith64Bits
++ #ifdef LV_HAVE_GENERIC
++-static inline void volk_32u_reverse_32u_2001magic(uint32_t* out, const uint32_t* in,
++- unsigned int num_points)
+++static inline void
+++volk_32u_reverse_32u_2001magic(uint32_t* out, const uint32_t* in, unsigned int num_points)
++ {
++- const uint32_t *in_ptr = in;
++- uint32_t *out_ptr = out;
++- const uint8_t *in8;
++- uint8_t *out8;
++- unsigned int number = 0;
++- for(; number < num_points; ++number){
++- in8 = (const uint8_t*)in_ptr;
++- out8 = (uint8_t*)out_ptr;
++- out8[3] = ((in8[0] * 0x80200802ULL) & 0x0884422110ULL) * 0x0101010101ULL >> 32;
++- out8[2] = ((in8[1] * 0x80200802ULL) & 0x0884422110ULL) * 0x0101010101ULL >> 32;
++- out8[1] = ((in8[2] * 0x80200802ULL) & 0x0884422110ULL) * 0x0101010101ULL >> 32;
++- out8[0] = ((in8[3] * 0x80200802ULL) & 0x0884422110ULL) * 0x0101010101ULL >> 32;
++- ++in_ptr;
++- ++out_ptr;
++- }
+++ const uint32_t* in_ptr = in;
+++ uint32_t* out_ptr = out;
+++ const uint8_t* in8;
+++ uint8_t* out8;
+++ unsigned int number = 0;
+++ for (; number < num_points; ++number) {
+++ in8 = (const uint8_t*)in_ptr;
+++ out8 = (uint8_t*)out_ptr;
+++ out8[3] = ((in8[0] * 0x80200802ULL) & 0x0884422110ULL) * 0x0101010101ULL >> 32;
+++ out8[2] = ((in8[1] * 0x80200802ULL) & 0x0884422110ULL) * 0x0101010101ULL >> 32;
+++ out8[1] = ((in8[2] * 0x80200802ULL) & 0x0884422110ULL) * 0x0101010101ULL >> 32;
+++ out8[0] = ((in8[3] * 0x80200802ULL) & 0x0884422110ULL) * 0x0101010101ULL >> 32;
+++ ++in_ptr;
+++ ++out_ptr;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_GENERIC
++ // Current gr-pager implementation
++-static inline void volk_32u_reverse_32u_1972magic(uint32_t* out, const uint32_t* in,
++- unsigned int num_points)
+++static inline void
+++volk_32u_reverse_32u_1972magic(uint32_t* out, const uint32_t* in, unsigned int num_points)
++ {
++- const uint32_t *in_ptr = in;
++- uint32_t *out_ptr = out;
++- const uint8_t *in8;
++- uint8_t *out8;
++- unsigned int number = 0;
++- for(; number < num_points; ++number){
++- in8 = (const uint8_t*)in_ptr;
++- out8 = (uint8_t*)out_ptr;
++- out8[3] = (in8[0] * 0x0202020202ULL & 0x010884422010ULL) % 1023;
++- out8[2] = (in8[1] * 0x0202020202ULL & 0x010884422010ULL) % 1023;
++- out8[1] = (in8[2] * 0x0202020202ULL & 0x010884422010ULL) % 1023;
++- out8[0] = (in8[3] * 0x0202020202ULL & 0x010884422010ULL) % 1023;
++- ++in_ptr;
++- ++out_ptr;
++- }
+++ const uint32_t* in_ptr = in;
+++ uint32_t* out_ptr = out;
+++ const uint8_t* in8;
+++ uint8_t* out8;
+++ unsigned int number = 0;
+++ for (; number < num_points; ++number) {
+++ in8 = (const uint8_t*)in_ptr;
+++ out8 = (uint8_t*)out_ptr;
+++ out8[3] = (in8[0] * 0x0202020202ULL & 0x010884422010ULL) % 1023;
+++ out8[2] = (in8[1] * 0x0202020202ULL & 0x010884422010ULL) % 1023;
+++ out8[1] = (in8[2] * 0x0202020202ULL & 0x010884422010ULL) % 1023;
+++ out8[0] = (in8[3] * 0x0202020202ULL & 0x010884422010ULL) % 1023;
+++ ++in_ptr;
+++ ++out_ptr;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++-//After lengthy thought and quite a bit of whiteboarding:
+++// After lengthy thought and quite a bit of whiteboarding:
++ #ifdef LV_HAVE_GENERIC
++-static inline void volk_32u_reverse_32u_bintree_permute_top_down(uint32_t* out, const uint32_t* in,
++- unsigned int num_points)
+++static inline void volk_32u_reverse_32u_bintree_permute_top_down(uint32_t* out,
+++ const uint32_t* in,
+++ unsigned int num_points)
++ {
++- const uint32_t *in_ptr = in;
++- uint32_t *out_ptr = out;
++- unsigned int number = 0;
++- for(; number < num_points; ++number){
++- uint32_t tmp = *in_ptr;
++- /* permute uint16:
++- The idea is to simply shift the lower 16 bit up, and the upper 16 bit down.
++- */
++- tmp = ( tmp << 16 ) | ( tmp >> 16 );
++- /* permute bytes:
++- shift up by 1 B first, then only consider even bytes, and OR with the unshifted even bytes
++- */
++- tmp = ((tmp & (0xFF | 0xFF << 16)) << 8) | ((tmp >> 8) & (0xFF | 0xFF << 16));
++- /* permute 4bit tuples:
++- Same idea, but the "consideration" mask expression becomes unwieldy
++- */
++- tmp = ((tmp & (0xF | 0xF << 8 | 0xF << 16 | 0xF << 24)) << 4) | ((tmp >> 4) & (0xF | 0xF << 8 | 0xF << 16 | 0xF << 24));
++- /* permute 2bit tuples:
++- Here, we collapsed the "consideration" mask to a simple hexmask: 0b0011 =
++- 3; we need those every 4b, which coincides with a hex digit!
++- */
++- tmp = ((tmp & (0x33333333)) << 2) | ((tmp >> 2) & (0x33333333));
++- /* permute odd/even:
++- 0x01 = 0x1; we need these every 2b, which works out: 0x01 | (0x01 << 2) = 0x05!
++- */
++- tmp = ((tmp & (0x55555555)) << 1) | ((tmp >> 1) & (0x55555555));
+++ const uint32_t* in_ptr = in;
+++ uint32_t* out_ptr = out;
+++ unsigned int number = 0;
+++ for (; number < num_points; ++number) {
+++ uint32_t tmp = *in_ptr;
+++ /* permute uint16:
+++ The idea is to simply shift the lower 16 bit up, and the upper 16 bit down.
+++ */
+++ tmp = (tmp << 16) | (tmp >> 16);
+++ /* permute bytes:
+++ shift up by 1 B first, then only consider even bytes, and OR with the unshifted
+++ even bytes
+++ */
+++ tmp = ((tmp & (0xFF | 0xFF << 16)) << 8) | ((tmp >> 8) & (0xFF | 0xFF << 16));
+++ /* permute 4bit tuples:
+++ Same idea, but the "consideration" mask expression becomes unwieldy
+++ */
+++ tmp = ((tmp & (0xF | 0xF << 8 | 0xF << 16 | 0xF << 24)) << 4) |
+++ ((tmp >> 4) & (0xF | 0xF << 8 | 0xF << 16 | 0xF << 24));
+++ /* permute 2bit tuples:
+++ Here, we collapsed the "consideration" mask to a simple hexmask: 0b0011 =
+++ 3; we need those every 4b, which coincides with a hex digit!
+++ */
+++ tmp = ((tmp & (0x33333333)) << 2) | ((tmp >> 2) & (0x33333333));
+++ /* permute odd/even:
+++ 0x01 = 0x1; we need these every 2b, which works out: 0x01 | (0x01 << 2) =
+++ 0x05!
+++ */
+++ tmp = ((tmp & (0x55555555)) << 1) | ((tmp >> 1) & (0x55555555));
++
++- *out_ptr = tmp;
++- ++in_ptr;
++- ++out_ptr;
++- }
+++ *out_ptr = tmp;
+++ ++in_ptr;
+++ ++out_ptr;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++ #ifdef LV_HAVE_GENERIC
++-static inline void volk_32u_reverse_32u_bintree_permute_bottom_up(uint32_t* out, const uint32_t* in,
++- unsigned int num_points)
+++static inline void volk_32u_reverse_32u_bintree_permute_bottom_up(uint32_t* out,
+++ const uint32_t* in,
+++ unsigned int num_points)
++ {
++- //same stuff as top_down, inverted order (permutation matrices don't care, you know!)
++- const uint32_t *in_ptr = in;
++- uint32_t *out_ptr = out;
++- unsigned int number = 0;
++- for(; number < num_points; ++number){
++- uint32_t tmp = *in_ptr;
++- tmp = ((tmp & (0x55555555)) << 1) | ((tmp >> 1) & (0x55555555));
++- tmp = ((tmp & (0x33333333)) << 2) | ((tmp >> 2) & (0x33333333));
++- tmp = ((tmp & (0xF | 0xF << 8 | 0xF << 16 | 0xF << 24)) << 4) | ((tmp >> 4) & (0xF | 0xF << 8 | 0xF << 16 | 0xF << 24));
++- tmp = ((tmp & (0xFF | 0xFF << 16)) << 8) | ((tmp >> 8) & (0xFF | 0xFF << 16));
++- tmp = ( tmp << 16 ) | ( tmp >> 16 );
+++ // same stuff as top_down, inverted order (permutation matrices don't care, you know!)
+++ const uint32_t* in_ptr = in;
+++ uint32_t* out_ptr = out;
+++ unsigned int number = 0;
+++ for (; number < num_points; ++number) {
+++ uint32_t tmp = *in_ptr;
+++ tmp = ((tmp & (0x55555555)) << 1) | ((tmp >> 1) & (0x55555555));
+++ tmp = ((tmp & (0x33333333)) << 2) | ((tmp >> 2) & (0x33333333));
+++ tmp = ((tmp & (0xF | 0xF << 8 | 0xF << 16 | 0xF << 24)) << 4) |
+++ ((tmp >> 4) & (0xF | 0xF << 8 | 0xF << 16 | 0xF << 24));
+++ tmp = ((tmp & (0xFF | 0xFF << 16)) << 8) | ((tmp >> 8) & (0xFF | 0xFF << 16));
+++ tmp = (tmp << 16) | (tmp >> 16);
++
++- *out_ptr = tmp;
++- ++in_ptr;
++- ++out_ptr;
++- }
+++ *out_ptr = tmp;
+++ ++in_ptr;
+++ ++out_ptr;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_NEONV8
++ #include <arm_neon.h>
++
++-static inline void volk_32u_reverse_32u_neonv8(uint32_t* out, const uint32_t* in,
++- unsigned int num_points)
++-{
++- const uint32_t *in_ptr = in;
++- uint32_t *out_ptr = out;
+++static inline void
+++volk_32u_reverse_32u_neonv8(uint32_t* out, const uint32_t* in, unsigned int num_points)
+++{
+++ const uint32_t* in_ptr = in;
+++ uint32_t* out_ptr = out;
++
++- const uint8x16_t idx = { 3,2,1,0, 7,6,5,4, 11,10,9,8, 15,14,13,12 };
+++ const uint8x16_t idx = { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 };
++
++- const unsigned int quarterPoints = num_points/4;
+++ const unsigned int quarterPoints = num_points / 4;
++ unsigned int number = 0;
++- for(; number < quarterPoints; ++number){
++- __VOLK_PREFETCH(in_ptr+4);
++- uint32x4_t x = vld1q_u32(in_ptr);
++- uint32x4_t z = vreinterpretq_u32_u8(vqtbl1q_u8(vrbitq_u8(vreinterpretq_u8_u32 (x)),
++- idx));
++- vst1q_u32 (out_ptr, z);
++- in_ptr += 4;
++- out_ptr += 4;
+++ for (; number < quarterPoints; ++number) {
+++ __VOLK_PREFETCH(in_ptr + 4);
+++ uint32x4_t x = vld1q_u32(in_ptr);
+++ uint32x4_t z =
+++ vreinterpretq_u32_u8(vqtbl1q_u8(vrbitq_u8(vreinterpretq_u8_u32(x)), idx));
+++ vst1q_u32(out_ptr, z);
+++ in_ptr += 4;
+++ out_ptr += 4;
++ }
++- number = quarterPoints*4;
++- for(; number < num_points; ++number){
++- *out_ptr =
++- (BitReverseTable256[*in_ptr & 0xff] << 24) |
++- (BitReverseTable256[(*in_ptr >> 8) & 0xff] << 16) |
++- (BitReverseTable256[(*in_ptr >> 16) & 0xff] << 8) |
++- (BitReverseTable256[(*in_ptr >> 24) & 0xff]);
++- ++in_ptr;
++- ++out_ptr;
+++ number = quarterPoints * 4;
+++ for (; number < num_points; ++number) {
+++ *out_ptr = (BitReverseTable256[*in_ptr & 0xff] << 24) |
+++ (BitReverseTable256[(*in_ptr >> 8) & 0xff] << 16) |
+++ (BitReverseTable256[(*in_ptr >> 16) & 0xff] << 8) |
+++ (BitReverseTable256[(*in_ptr >> 24) & 0xff]);
+++ ++in_ptr;
+++ ++out_ptr;
++ }
++ }
++
++@@ -371,29 +378,35 @@ static inline void volk_32u_reverse_32u_neonv8(uint32_t* out, const uint32_t* in
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-#define DO_RBIT \
++- __VOLK_ASM("rbit %[result], %[value]" \
++- : [result]"=r" (*out_ptr) \
++- : [value] "r" (*in_ptr) \
++- : ); \
++- in_ptr++; \
++- out_ptr++;
+++#define DO_RBIT \
+++ __VOLK_ASM("rbit %[result], %[value]" \
+++ : [result] "=r"(*out_ptr) \
+++ : [value] "r"(*in_ptr) \
+++ :); \
+++ in_ptr++; \
+++ out_ptr++;
++
++-static inline void volk_32u_reverse_32u_arm(uint32_t* out, const uint32_t* in,
++- unsigned int num_points)
+++static inline void
+++volk_32u_reverse_32u_arm(uint32_t* out, const uint32_t* in, unsigned int num_points)
++ {
++
++- const uint32_t *in_ptr = in;
++- uint32_t *out_ptr = out;
++- const unsigned int eighthPoints = num_points/8;
+++ const uint32_t* in_ptr = in;
+++ uint32_t* out_ptr = out;
+++ const unsigned int eighthPoints = num_points / 8;
++ unsigned int number = 0;
++- for(; number < eighthPoints; ++number){
++- __VOLK_PREFETCH(in_ptr+8);
++- DO_RBIT; DO_RBIT; DO_RBIT; DO_RBIT;
++- DO_RBIT; DO_RBIT; DO_RBIT; DO_RBIT;
+++ for (; number < eighthPoints; ++number) {
+++ __VOLK_PREFETCH(in_ptr + 8);
+++ DO_RBIT;
+++ DO_RBIT;
+++ DO_RBIT;
+++ DO_RBIT;
+++ DO_RBIT;
+++ DO_RBIT;
+++ DO_RBIT;
+++ DO_RBIT;
++ }
++- number = eighthPoints*8;
++- for(; number < num_points; ++number){
+++ number = eighthPoints * 8;
+++ for (; number < num_points; ++number) {
++ DO_RBIT;
++ }
++ }
++@@ -403,4 +416,3 @@ static inline void volk_32u_reverse_32u_arm(uint32_t* out, const uint32_t* in,
++
++
++ #endif /* INCLUDED_volk_32u_reverse_32u_u_H */
++-
++diff --git a/kernels/volk/volk_64f_convert_32f.h b/kernels/volk/volk_64f_convert_32f.h
++index 20422cf..4ebccc0 100644
++--- a/kernels/volk/volk_64f_convert_32f.h
+++++ b/kernels/volk/volk_64f_convert_32f.h
++@@ -29,8 +29,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_64f_convert_32f(float* outputVector, const double* inputVector, unsigned int num_points)
++- * \endcode
+++ * void volk_64f_convert_32f(float* outputVector, const double* inputVector, unsigned int
+++ * num_points) \endcode
++ *
++ * \b Inputs
++ * \li inputVector: The vector of doubles to convert to floats.
++@@ -70,34 +70,39 @@
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void volk_64f_convert_32f_u_avx512f(float* outputVector, const double* inputVector, unsigned int num_points){
++- unsigned int number = 0;
+++static inline void volk_64f_convert_32f_u_avx512f(float* outputVector,
+++ const double* inputVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
++
++- const unsigned int oneSixteenthPoints = num_points / 16;
+++ const unsigned int oneSixteenthPoints = num_points / 16;
++
++- const double* inputVectorPtr = (const double*)inputVector;
++- float* outputVectorPtr = outputVector;
++- __m256 ret1, ret2;
++- __m512d inputVal1, inputVal2;
+++ const double* inputVectorPtr = (const double*)inputVector;
+++ float* outputVectorPtr = outputVector;
+++ __m256 ret1, ret2;
+++ __m512d inputVal1, inputVal2;
++
++- for(;number < oneSixteenthPoints; number++){
++- inputVal1 = _mm512_loadu_pd(inputVectorPtr); inputVectorPtr += 8;
++- inputVal2 = _mm512_loadu_pd(inputVectorPtr); inputVectorPtr += 8;
+++ for (; number < oneSixteenthPoints; number++) {
+++ inputVal1 = _mm512_loadu_pd(inputVectorPtr);
+++ inputVectorPtr += 8;
+++ inputVal2 = _mm512_loadu_pd(inputVectorPtr);
+++ inputVectorPtr += 8;
++
++- ret1 = _mm512_cvtpd_ps(inputVal1);
++- ret2 = _mm512_cvtpd_ps(inputVal2);
+++ ret1 = _mm512_cvtpd_ps(inputVal1);
+++ ret2 = _mm512_cvtpd_ps(inputVal2);
++
++- _mm256_storeu_ps(outputVectorPtr, ret1);
++- outputVectorPtr += 8;
+++ _mm256_storeu_ps(outputVectorPtr, ret1);
+++ outputVectorPtr += 8;
++
++- _mm256_storeu_ps(outputVectorPtr, ret2);
++- outputVectorPtr += 8;
++- }
+++ _mm256_storeu_ps(outputVectorPtr, ret2);
+++ outputVectorPtr += 8;
+++ }
++
++- number = oneSixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] = (float)(inputVector[number]);
++- }
+++ number = oneSixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (float)(inputVector[number]);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++@@ -105,34 +110,39 @@ static inline void volk_64f_convert_32f_u_avx512f(float* outputVector, const dou
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_64f_convert_32f_u_avx(float* outputVector, const double* inputVector, unsigned int num_points){
++- unsigned int number = 0;
+++static inline void volk_64f_convert_32f_u_avx(float* outputVector,
+++ const double* inputVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
++
++- const unsigned int oneEightPoints = num_points / 8;
+++ const unsigned int oneEightPoints = num_points / 8;
++
++- const double* inputVectorPtr = (const double*)inputVector;
++- float* outputVectorPtr = outputVector;
++- __m128 ret1, ret2;
++- __m256d inputVal1, inputVal2;
+++ const double* inputVectorPtr = (const double*)inputVector;
+++ float* outputVectorPtr = outputVector;
+++ __m128 ret1, ret2;
+++ __m256d inputVal1, inputVal2;
++
++- for(;number < oneEightPoints; number++){
++- inputVal1 = _mm256_loadu_pd(inputVectorPtr); inputVectorPtr += 4;
++- inputVal2 = _mm256_loadu_pd(inputVectorPtr); inputVectorPtr += 4;
+++ for (; number < oneEightPoints; number++) {
+++ inputVal1 = _mm256_loadu_pd(inputVectorPtr);
+++ inputVectorPtr += 4;
+++ inputVal2 = _mm256_loadu_pd(inputVectorPtr);
+++ inputVectorPtr += 4;
++
++- ret1 = _mm256_cvtpd_ps(inputVal1);
++- ret2 = _mm256_cvtpd_ps(inputVal2);
+++ ret1 = _mm256_cvtpd_ps(inputVal1);
+++ ret2 = _mm256_cvtpd_ps(inputVal2);
++
++- _mm_storeu_ps(outputVectorPtr, ret1);
++- outputVectorPtr += 4;
+++ _mm_storeu_ps(outputVectorPtr, ret1);
+++ outputVectorPtr += 4;
++
++- _mm_storeu_ps(outputVectorPtr, ret2);
++- outputVectorPtr += 4;
++- }
+++ _mm_storeu_ps(outputVectorPtr, ret2);
+++ outputVectorPtr += 4;
+++ }
++
++- number = oneEightPoints * 8;
++- for(; number < num_points; number++){
++- outputVector[number] = (float)(inputVector[number]);
++- }
+++ number = oneEightPoints * 8;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (float)(inputVector[number]);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -140,53 +150,59 @@ static inline void volk_64f_convert_32f_u_avx(float* outputVector, const double*
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_64f_convert_32f_u_sse2(float* outputVector, const double* inputVector, unsigned int num_points){
++- unsigned int number = 0;
+++static inline void volk_64f_convert_32f_u_sse2(float* outputVector,
+++ const double* inputVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
++
++- const unsigned int quarterPoints = num_points / 4;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const double* inputVectorPtr = (const double*)inputVector;
++- float* outputVectorPtr = outputVector;
++- __m128 ret, ret2;
++- __m128d inputVal1, inputVal2;
+++ const double* inputVectorPtr = (const double*)inputVector;
+++ float* outputVectorPtr = outputVector;
+++ __m128 ret, ret2;
+++ __m128d inputVal1, inputVal2;
++
++- for(;number < quarterPoints; number++){
++- inputVal1 = _mm_loadu_pd(inputVectorPtr); inputVectorPtr += 2;
++- inputVal2 = _mm_loadu_pd(inputVectorPtr); inputVectorPtr += 2;
+++ for (; number < quarterPoints; number++) {
+++ inputVal1 = _mm_loadu_pd(inputVectorPtr);
+++ inputVectorPtr += 2;
+++ inputVal2 = _mm_loadu_pd(inputVectorPtr);
+++ inputVectorPtr += 2;
++
++- ret = _mm_cvtpd_ps(inputVal1);
++- ret2 = _mm_cvtpd_ps(inputVal2);
+++ ret = _mm_cvtpd_ps(inputVal1);
+++ ret2 = _mm_cvtpd_ps(inputVal2);
++
++- ret = _mm_movelh_ps(ret, ret2);
+++ ret = _mm_movelh_ps(ret, ret2);
++
++- _mm_storeu_ps(outputVectorPtr, ret);
++- outputVectorPtr += 4;
++- }
+++ _mm_storeu_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- outputVector[number] = (float)(inputVector[number]);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (float)(inputVector[number]);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_64f_convert_32f_generic(float* outputVector, const double* inputVector, unsigned int num_points){
++- float* outputVectorPtr = outputVector;
++- const double* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((float)(*inputVectorPtr++));
++- }
+++static inline void volk_64f_convert_32f_generic(float* outputVector,
+++ const double* inputVector,
+++ unsigned int num_points)
+++{
+++ float* outputVectorPtr = outputVector;
+++ const double* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((float)(*inputVectorPtr++));
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++-
++ #endif /* INCLUDED_volk_64f_convert_32f_u_H */
++ #ifndef INCLUDED_volk_64f_convert_32f_a_H
++ #define INCLUDED_volk_64f_convert_32f_a_H
++@@ -197,34 +213,39 @@ static inline void volk_64f_convert_32f_generic(float* outputVector, const doubl
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void volk_64f_convert_32f_a_avx512f(float* outputVector, const double* inputVector, unsigned int num_points){
++- unsigned int number = 0;
+++static inline void volk_64f_convert_32f_a_avx512f(float* outputVector,
+++ const double* inputVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
++
++- const unsigned int oneSixteenthPoints = num_points / 16;
+++ const unsigned int oneSixteenthPoints = num_points / 16;
++
++- const double* inputVectorPtr = (const double*)inputVector;
++- float* outputVectorPtr = outputVector;
++- __m256 ret1, ret2;
++- __m512d inputVal1, inputVal2;
+++ const double* inputVectorPtr = (const double*)inputVector;
+++ float* outputVectorPtr = outputVector;
+++ __m256 ret1, ret2;
+++ __m512d inputVal1, inputVal2;
++
++- for(;number < oneSixteenthPoints; number++){
++- inputVal1 = _mm512_load_pd(inputVectorPtr); inputVectorPtr += 8;
++- inputVal2 = _mm512_load_pd(inputVectorPtr); inputVectorPtr += 8;
+++ for (; number < oneSixteenthPoints; number++) {
+++ inputVal1 = _mm512_load_pd(inputVectorPtr);
+++ inputVectorPtr += 8;
+++ inputVal2 = _mm512_load_pd(inputVectorPtr);
+++ inputVectorPtr += 8;
++
++- ret1 = _mm512_cvtpd_ps(inputVal1);
++- ret2 = _mm512_cvtpd_ps(inputVal2);
+++ ret1 = _mm512_cvtpd_ps(inputVal1);
+++ ret2 = _mm512_cvtpd_ps(inputVal2);
++
++- _mm256_store_ps(outputVectorPtr, ret1);
++- outputVectorPtr += 8;
+++ _mm256_store_ps(outputVectorPtr, ret1);
+++ outputVectorPtr += 8;
++
++- _mm256_store_ps(outputVectorPtr, ret2);
++- outputVectorPtr += 8;
++- }
+++ _mm256_store_ps(outputVectorPtr, ret2);
+++ outputVectorPtr += 8;
+++ }
++
++- number = oneSixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] = (float)(inputVector[number]);
++- }
+++ number = oneSixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (float)(inputVector[number]);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++@@ -232,34 +253,39 @@ static inline void volk_64f_convert_32f_a_avx512f(float* outputVector, const dou
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void volk_64f_convert_32f_a_avx(float* outputVector, const double* inputVector, unsigned int num_points){
++- unsigned int number = 0;
+++static inline void volk_64f_convert_32f_a_avx(float* outputVector,
+++ const double* inputVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
++
++- const unsigned int oneEightPoints = num_points / 8;
+++ const unsigned int oneEightPoints = num_points / 8;
++
++- const double* inputVectorPtr = (const double*)inputVector;
++- float* outputVectorPtr = outputVector;
++- __m128 ret1, ret2;
++- __m256d inputVal1, inputVal2;
+++ const double* inputVectorPtr = (const double*)inputVector;
+++ float* outputVectorPtr = outputVector;
+++ __m128 ret1, ret2;
+++ __m256d inputVal1, inputVal2;
++
++- for(;number < oneEightPoints; number++){
++- inputVal1 = _mm256_load_pd(inputVectorPtr); inputVectorPtr += 4;
++- inputVal2 = _mm256_load_pd(inputVectorPtr); inputVectorPtr += 4;
+++ for (; number < oneEightPoints; number++) {
+++ inputVal1 = _mm256_load_pd(inputVectorPtr);
+++ inputVectorPtr += 4;
+++ inputVal2 = _mm256_load_pd(inputVectorPtr);
+++ inputVectorPtr += 4;
++
++- ret1 = _mm256_cvtpd_ps(inputVal1);
++- ret2 = _mm256_cvtpd_ps(inputVal2);
+++ ret1 = _mm256_cvtpd_ps(inputVal1);
+++ ret2 = _mm256_cvtpd_ps(inputVal2);
++
++- _mm_store_ps(outputVectorPtr, ret1);
++- outputVectorPtr += 4;
+++ _mm_store_ps(outputVectorPtr, ret1);
+++ outputVectorPtr += 4;
++
++- _mm_store_ps(outputVectorPtr, ret2);
++- outputVectorPtr += 4;
++- }
+++ _mm_store_ps(outputVectorPtr, ret2);
+++ outputVectorPtr += 4;
+++ }
++
++- number = oneEightPoints * 8;
++- for(; number < num_points; number++){
++- outputVector[number] = (float)(inputVector[number]);
++- }
+++ number = oneEightPoints * 8;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (float)(inputVector[number]);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -267,51 +293,57 @@ static inline void volk_64f_convert_32f_a_avx(float* outputVector, const double*
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_64f_convert_32f_a_sse2(float* outputVector, const double* inputVector, unsigned int num_points){
++- unsigned int number = 0;
+++static inline void volk_64f_convert_32f_a_sse2(float* outputVector,
+++ const double* inputVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
++
++- const unsigned int quarterPoints = num_points / 4;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- const double* inputVectorPtr = (const double*)inputVector;
++- float* outputVectorPtr = outputVector;
++- __m128 ret, ret2;
++- __m128d inputVal1, inputVal2;
+++ const double* inputVectorPtr = (const double*)inputVector;
+++ float* outputVectorPtr = outputVector;
+++ __m128 ret, ret2;
+++ __m128d inputVal1, inputVal2;
++
++- for(;number < quarterPoints; number++){
++- inputVal1 = _mm_load_pd(inputVectorPtr); inputVectorPtr += 2;
++- inputVal2 = _mm_load_pd(inputVectorPtr); inputVectorPtr += 2;
+++ for (; number < quarterPoints; number++) {
+++ inputVal1 = _mm_load_pd(inputVectorPtr);
+++ inputVectorPtr += 2;
+++ inputVal2 = _mm_load_pd(inputVectorPtr);
+++ inputVectorPtr += 2;
++
++- ret = _mm_cvtpd_ps(inputVal1);
++- ret2 = _mm_cvtpd_ps(inputVal2);
+++ ret = _mm_cvtpd_ps(inputVal1);
+++ ret2 = _mm_cvtpd_ps(inputVal2);
++
++- ret = _mm_movelh_ps(ret, ret2);
+++ ret = _mm_movelh_ps(ret, ret2);
++
++- _mm_store_ps(outputVectorPtr, ret);
++- outputVectorPtr += 4;
++- }
+++ _mm_store_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- outputVector[number] = (float)(inputVector[number]);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (float)(inputVector[number]);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_64f_convert_32f_a_generic(float* outputVector, const double* inputVector, unsigned int num_points){
++- float* outputVectorPtr = outputVector;
++- const double* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((float)(*inputVectorPtr++));
++- }
+++static inline void volk_64f_convert_32f_a_generic(float* outputVector,
+++ const double* inputVector,
+++ unsigned int num_points)
+++{
+++ float* outputVectorPtr = outputVector;
+++ const double* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((float)(*inputVectorPtr++));
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++-
++ #endif /* INCLUDED_volk_64f_convert_32f_a_H */
++diff --git a/kernels/volk/volk_64f_x2_add_64f.h b/kernels/volk/volk_64f_x2_add_64f.h
++index 03b8e4c..5c512cc 100644
++--- a/kernels/volk/volk_64f_x2_add_64f.h
+++++ b/kernels/volk/volk_64f_x2_add_64f.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_64f_x2_add_64f(float* cVector, const float* aVector, const float* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_64f_x2_add_64f(float* cVector, const float* aVector, const float* bVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: First input vector.
++@@ -76,18 +76,19 @@
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_64f_x2_add_64f_generic(double *cVector, const double *aVector,
++- const double *bVector, unsigned int num_points)
+++static inline void volk_64f_x2_add_64f_generic(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- double *cPtr = cVector;
++- const double *aPtr = aVector;
++- const double *bPtr = bVector;
++- unsigned int number = 0;
++-
++- for (number = 0; number < num_points; number++) {
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -100,35 +101,36 @@ volk_64f_x2_add_64f_generic(double *cVector, const double *aVector,
++
++ #include <emmintrin.h>
++
++-static inline void
++-volk_64f_x2_add_64f_u_sse2(double *cVector, const double *aVector,
++- const double *bVector, unsigned int num_points)
+++static inline void volk_64f_x2_add_64f_u_sse2(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int half_points = num_points / 2;
+++ unsigned int number = 0;
+++ const unsigned int half_points = num_points / 2;
++
++- double *cPtr = cVector;
++- const double *aPtr = aVector;
++- const double *bPtr = bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m128d aVal, bVal, cVal;
++- for (; number < half_points; number++) {
++- aVal = _mm_loadu_pd(aPtr);
++- bVal = _mm_loadu_pd(bPtr);
+++ __m128d aVal, bVal, cVal;
+++ for (; number < half_points; number++) {
+++ aVal = _mm_loadu_pd(aPtr);
+++ bVal = _mm_loadu_pd(bPtr);
++
++- cVal = _mm_add_pd(aVal, bVal);
+++ cVal = _mm_add_pd(aVal, bVal);
++
++- _mm_storeu_pd(cPtr, cVal); // Store the results back into the C container
+++ _mm_storeu_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 2;
++- bPtr += 2;
++- cPtr += 2;
++- }
+++ aPtr += 2;
+++ bPtr += 2;
+++ cPtr += 2;
+++ }
++
++- number = half_points * 2;
++- for (; number < num_points; number++) {
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ number = half_points * 2;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE2 */
++@@ -138,36 +140,37 @@ volk_64f_x2_add_64f_u_sse2(double *cVector, const double *aVector,
++
++ #include <immintrin.h>
++
++-static inline void
++-volk_64f_x2_add_64f_u_avx(double *cVector, const double *aVector,
++- const double *bVector, unsigned int num_points)
+++static inline void volk_64f_x2_add_64f_u_avx(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarter_points = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarter_points = num_points / 4;
++
++- double *cPtr = cVector;
++- const double *aPtr = aVector;
++- const double *bPtr = bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m256d aVal, bVal, cVal;
++- for (; number < quarter_points; number++) {
+++ __m256d aVal, bVal, cVal;
+++ for (; number < quarter_points; number++) {
++
++- aVal = _mm256_loadu_pd(aPtr);
++- bVal = _mm256_loadu_pd(bPtr);
+++ aVal = _mm256_loadu_pd(aPtr);
+++ bVal = _mm256_loadu_pd(bPtr);
++
++- cVal = _mm256_add_pd(aVal, bVal);
+++ cVal = _mm256_add_pd(aVal, bVal);
++
++- _mm256_storeu_pd(cPtr, cVal); // Store the results back into the C container
+++ _mm256_storeu_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarter_points * 4;
++- for (; number < num_points; number++) {
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ number = quarter_points * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++@@ -180,35 +183,36 @@ volk_64f_x2_add_64f_u_avx(double *cVector, const double *aVector,
++
++ #include <emmintrin.h>
++
++-static inline void
++-volk_64f_x2_add_64f_a_sse2(double *cVector, const double *aVector,
++- const double *bVector, unsigned int num_points)
+++static inline void volk_64f_x2_add_64f_a_sse2(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int half_points = num_points / 2;
+++ unsigned int number = 0;
+++ const unsigned int half_points = num_points / 2;
++
++- double *cPtr = cVector;
++- const double *aPtr = aVector;
++- const double *bPtr = bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m128d aVal, bVal, cVal;
++- for (; number < half_points; number++) {
++- aVal = _mm_load_pd(aPtr);
++- bVal = _mm_load_pd(bPtr);
+++ __m128d aVal, bVal, cVal;
+++ for (; number < half_points; number++) {
+++ aVal = _mm_load_pd(aPtr);
+++ bVal = _mm_load_pd(bPtr);
++
++- cVal = _mm_add_pd(aVal, bVal);
+++ cVal = _mm_add_pd(aVal, bVal);
++
++- _mm_store_pd(cPtr, cVal); // Store the results back into the C container
+++ _mm_store_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 2;
++- bPtr += 2;
++- cPtr += 2;
++- }
+++ aPtr += 2;
+++ bPtr += 2;
+++ cPtr += 2;
+++ }
++
++- number = half_points * 2;
++- for (; number < num_points; number++) {
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ number = half_points * 2;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE2 */
++@@ -218,36 +222,37 @@ volk_64f_x2_add_64f_a_sse2(double *cVector, const double *aVector,
++
++ #include <immintrin.h>
++
++-static inline void
++-volk_64f_x2_add_64f_a_avx(double *cVector, const double *aVector,
++- const double *bVector, unsigned int num_points)
+++static inline void volk_64f_x2_add_64f_a_avx(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarter_points = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarter_points = num_points / 4;
++
++- double *cPtr = cVector;
++- const double *aPtr = aVector;
++- const double *bPtr = bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m256d aVal, bVal, cVal;
++- for (; number < quarter_points; number++) {
+++ __m256d aVal, bVal, cVal;
+++ for (; number < quarter_points; number++) {
++
++- aVal = _mm256_load_pd(aPtr);
++- bVal = _mm256_load_pd(bPtr);
+++ aVal = _mm256_load_pd(aPtr);
+++ bVal = _mm256_load_pd(bPtr);
++
++- cVal = _mm256_add_pd(aVal, bVal);
+++ cVal = _mm256_add_pd(aVal, bVal);
++
++- _mm256_store_pd(cPtr, cVal); // Store the results back into the C container
+++ _mm256_store_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarter_points * 4;
++- for (; number < num_points; number++) {
++- *cPtr++ = (*aPtr++) + (*bPtr++);
++- }
+++ number = quarter_points * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) + (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++diff --git a/kernels/volk/volk_64f_x2_max_64f.h b/kernels/volk/volk_64f_x2_max_64f.h
++index d4464b7..8f7f743 100644
++--- a/kernels/volk/volk_64f_x2_max_64f.h
+++++ b/kernels/volk/volk_64f_x2_max_64f.h
++@@ -32,8 +32,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_64f_x2_max_64f(double* cVector, const double* aVector, const double* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_64f_x2_max_64f(double* cVector, const double* aVector, const double* bVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: First input vector.
++@@ -77,38 +77,39 @@
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_64f_x2_max_64f_a_avx512f(double* cVector, const double* aVector,
++- const double* bVector, unsigned int num_points)
+++static inline void volk_64f_x2_max_64f_a_avx512f(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eigthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eigthPoints = num_points / 8;
++
++- double* cPtr = cVector;
++- const double* aPtr = aVector;
++- const double* bPtr= bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m512d aVal, bVal, cVal;
++- for(;number < eigthPoints; number++){
+++ __m512d aVal, bVal, cVal;
+++ for (; number < eigthPoints; number++) {
++
++- aVal = _mm512_load_pd(aPtr);
++- bVal = _mm512_load_pd(bPtr);
+++ aVal = _mm512_load_pd(aPtr);
+++ bVal = _mm512_load_pd(bPtr);
++
++- cVal = _mm512_max_pd(aVal, bVal);
+++ cVal = _mm512_max_pd(aVal, bVal);
++
++- _mm512_store_pd(cPtr,cVal); // Store the results back into the C container
+++ _mm512_store_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eigthPoints * 8;
++- for(;number < num_points; number++){
++- const double a = *aPtr++;
++- const double b = *bPtr++;
++- *cPtr++ = ( a > b ? a : b);
++- }
+++ number = eigthPoints * 8;
+++ for (; number < num_points; number++) {
+++ const double a = *aPtr++;
+++ const double b = *bPtr++;
+++ *cPtr++ = (a > b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++@@ -116,38 +117,39 @@ volk_64f_x2_max_64f_a_avx512f(double* cVector, const double* aVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_64f_x2_max_64f_a_avx(double* cVector, const double* aVector,
++- const double* bVector, unsigned int num_points)
+++static inline void volk_64f_x2_max_64f_a_avx(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- double* cPtr = cVector;
++- const double* aPtr = aVector;
++- const double* bPtr= bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m256d aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
+++ __m256d aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm256_load_pd(aPtr);
++- bVal = _mm256_load_pd(bPtr);
+++ aVal = _mm256_load_pd(aPtr);
+++ bVal = _mm256_load_pd(bPtr);
++
++- cVal = _mm256_max_pd(aVal, bVal);
+++ cVal = _mm256_max_pd(aVal, bVal);
++
++- _mm256_store_pd(cPtr,cVal); // Store the results back into the C container
+++ _mm256_store_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- const double a = *aPtr++;
++- const double b = *bPtr++;
++- *cPtr++ = ( a > b ? a : b);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ const double a = *aPtr++;
+++ const double b = *bPtr++;
+++ *cPtr++ = (a > b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -155,58 +157,60 @@ volk_64f_x2_max_64f_a_avx(double* cVector, const double* aVector,
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_64f_x2_max_64f_a_sse2(double* cVector, const double* aVector,
++- const double* bVector, unsigned int num_points)
+++static inline void volk_64f_x2_max_64f_a_sse2(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int halfPoints = num_points / 2;
+++ unsigned int number = 0;
+++ const unsigned int halfPoints = num_points / 2;
++
++- double* cPtr = cVector;
++- const double* aPtr = aVector;
++- const double* bPtr= bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m128d aVal, bVal, cVal;
++- for(;number < halfPoints; number++){
+++ __m128d aVal, bVal, cVal;
+++ for (; number < halfPoints; number++) {
++
++- aVal = _mm_load_pd(aPtr);
++- bVal = _mm_load_pd(bPtr);
+++ aVal = _mm_load_pd(aPtr);
+++ bVal = _mm_load_pd(bPtr);
++
++- cVal = _mm_max_pd(aVal, bVal);
+++ cVal = _mm_max_pd(aVal, bVal);
++
++- _mm_store_pd(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 2;
++- bPtr += 2;
++- cPtr += 2;
++- }
+++ aPtr += 2;
+++ bPtr += 2;
+++ cPtr += 2;
+++ }
++
++- number = halfPoints * 2;
++- for(;number < num_points; number++){
++- const double a = *aPtr++;
++- const double b = *bPtr++;
++- *cPtr++ = ( a > b ? a : b);
++- }
+++ number = halfPoints * 2;
+++ for (; number < num_points; number++) {
+++ const double a = *aPtr++;
+++ const double b = *bPtr++;
+++ *cPtr++ = (a > b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_64f_x2_max_64f_generic(double* cVector, const double* aVector,
++- const double* bVector, unsigned int num_points)
+++static inline void volk_64f_x2_max_64f_generic(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- double* cPtr = cVector;
++- const double* aPtr = aVector;
++- const double* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- const double a = *aPtr++;
++- const double b = *bPtr++;
++- *cPtr++ = ( a > b ? a : b);
++- }
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ const double a = *aPtr++;
+++ const double b = *bPtr++;
+++ *cPtr++ = (a > b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -223,38 +227,39 @@ volk_64f_x2_max_64f_generic(double* cVector, const double* aVector,
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_64f_x2_max_64f_u_avx512f(double* cVector, const double* aVector,
++- const double* bVector, unsigned int num_points)
+++static inline void volk_64f_x2_max_64f_u_avx512f(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eigthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eigthPoints = num_points / 8;
++
++- double* cPtr = cVector;
++- const double* aPtr = aVector;
++- const double* bPtr= bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m512d aVal, bVal, cVal;
++- for(;number < eigthPoints; number++){
+++ __m512d aVal, bVal, cVal;
+++ for (; number < eigthPoints; number++) {
++
++- aVal = _mm512_loadu_pd(aPtr);
++- bVal = _mm512_loadu_pd(bPtr);
+++ aVal = _mm512_loadu_pd(aPtr);
+++ bVal = _mm512_loadu_pd(bPtr);
++
++- cVal = _mm512_max_pd(aVal, bVal);
+++ cVal = _mm512_max_pd(aVal, bVal);
++
++- _mm512_storeu_pd(cPtr,cVal); // Store the results back into the C container
+++ _mm512_storeu_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eigthPoints * 8;
++- for(;number < num_points; number++){
++- const double a = *aPtr++;
++- const double b = *bPtr++;
++- *cPtr++ = ( a > b ? a : b);
++- }
+++ number = eigthPoints * 8;
+++ for (; number < num_points; number++) {
+++ const double a = *aPtr++;
+++ const double b = *bPtr++;
+++ *cPtr++ = (a > b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++@@ -262,38 +267,39 @@ volk_64f_x2_max_64f_u_avx512f(double* cVector, const double* aVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_64f_x2_max_64f_u_avx(double* cVector, const double* aVector,
++- const double* bVector, unsigned int num_points)
+++static inline void volk_64f_x2_max_64f_u_avx(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- double* cPtr = cVector;
++- const double* aPtr = aVector;
++- const double* bPtr= bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m256d aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
+++ __m256d aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm256_loadu_pd(aPtr);
++- bVal = _mm256_loadu_pd(bPtr);
+++ aVal = _mm256_loadu_pd(aPtr);
+++ bVal = _mm256_loadu_pd(bPtr);
++
++- cVal = _mm256_max_pd(aVal, bVal);
+++ cVal = _mm256_max_pd(aVal, bVal);
++
++- _mm256_storeu_pd(cPtr,cVal); // Store the results back into the C container
+++ _mm256_storeu_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- const double a = *aPtr++;
++- const double b = *bPtr++;
++- *cPtr++ = ( a > b ? a : b);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ const double a = *aPtr++;
+++ const double b = *bPtr++;
+++ *cPtr++ = (a > b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++diff --git a/kernels/volk/volk_64f_x2_min_64f.h b/kernels/volk/volk_64f_x2_min_64f.h
++index 0ffa305..7dc4d59 100644
++--- a/kernels/volk/volk_64f_x2_min_64f.h
+++++ b/kernels/volk/volk_64f_x2_min_64f.h
++@@ -32,7 +32,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_64f_x2_min_64f(double* cVector, const double* aVector, const double* bVector, unsigned int num_points)
+++ * void volk_64f_x2_min_64f(double* cVector, const double* aVector, const double* bVector,
+++ unsigned int num_points)
++ * \endcode
++ *
++ * \b Inputs
++@@ -77,38 +78,39 @@
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_64f_x2_min_64f_a_avx512f(double* cVector, const double* aVector,
++- const double* bVector, unsigned int num_points)
+++static inline void volk_64f_x2_min_64f_a_avx512f(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eigthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eigthPoints = num_points / 8;
++
++- double* cPtr = cVector;
++- const double* aPtr = aVector;
++- const double* bPtr= bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m512d aVal, bVal, cVal;
++- for(;number < eigthPoints; number++){
+++ __m512d aVal, bVal, cVal;
+++ for (; number < eigthPoints; number++) {
++
++- aVal = _mm512_load_pd(aPtr);
++- bVal = _mm512_load_pd(bPtr);
+++ aVal = _mm512_load_pd(aPtr);
+++ bVal = _mm512_load_pd(bPtr);
++
++- cVal = _mm512_min_pd(aVal, bVal);
+++ cVal = _mm512_min_pd(aVal, bVal);
++
++- _mm512_store_pd(cPtr,cVal); // Store the results back into the C container
+++ _mm512_store_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eigthPoints * 8;
++- for(;number < num_points; number++){
++- const double a = *aPtr++;
++- const double b = *bPtr++;
++- *cPtr++ = ( a < b ? a : b);
++- }
+++ number = eigthPoints * 8;
+++ for (; number < num_points; number++) {
+++ const double a = *aPtr++;
+++ const double b = *bPtr++;
+++ *cPtr++ = (a < b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++@@ -116,38 +118,39 @@ volk_64f_x2_min_64f_a_avx512f(double* cVector, const double* aVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_64f_x2_min_64f_a_avx(double* cVector, const double* aVector,
++- const double* bVector, unsigned int num_points)
+++static inline void volk_64f_x2_min_64f_a_avx(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- double* cPtr = cVector;
++- const double* aPtr = aVector;
++- const double* bPtr= bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m256d aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
+++ __m256d aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm256_load_pd(aPtr);
++- bVal = _mm256_load_pd(bPtr);
+++ aVal = _mm256_load_pd(aPtr);
+++ bVal = _mm256_load_pd(bPtr);
++
++- cVal = _mm256_min_pd(aVal, bVal);
+++ cVal = _mm256_min_pd(aVal, bVal);
++
++- _mm256_store_pd(cPtr,cVal); // Store the results back into the C container
+++ _mm256_store_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- const double a = *aPtr++;
++- const double b = *bPtr++;
++- *cPtr++ = ( a < b ? a : b);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ const double a = *aPtr++;
+++ const double b = *bPtr++;
+++ *cPtr++ = (a < b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++@@ -155,58 +158,60 @@ volk_64f_x2_min_64f_a_avx(double* cVector, const double* aVector,
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void
++-volk_64f_x2_min_64f_a_sse2(double* cVector, const double* aVector,
++- const double* bVector, unsigned int num_points)
+++static inline void volk_64f_x2_min_64f_a_sse2(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int halfPoints = num_points / 2;
+++ unsigned int number = 0;
+++ const unsigned int halfPoints = num_points / 2;
++
++- double* cPtr = cVector;
++- const double* aPtr = aVector;
++- const double* bPtr= bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m128d aVal, bVal, cVal;
++- for(;number < halfPoints; number++){
+++ __m128d aVal, bVal, cVal;
+++ for (; number < halfPoints; number++) {
++
++- aVal = _mm_load_pd(aPtr);
++- bVal = _mm_load_pd(bPtr);
+++ aVal = _mm_load_pd(aPtr);
+++ bVal = _mm_load_pd(bPtr);
++
++- cVal = _mm_min_pd(aVal, bVal);
+++ cVal = _mm_min_pd(aVal, bVal);
++
++- _mm_store_pd(cPtr,cVal); // Store the results back into the C container
+++ _mm_store_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 2;
++- bPtr += 2;
++- cPtr += 2;
++- }
+++ aPtr += 2;
+++ bPtr += 2;
+++ cPtr += 2;
+++ }
++
++- number = halfPoints * 2;
++- for(;number < num_points; number++){
++- const double a = *aPtr++;
++- const double b = *bPtr++;
++- *cPtr++ = ( a < b ? a : b);
++- }
+++ number = halfPoints * 2;
+++ for (; number < num_points; number++) {
+++ const double a = *aPtr++;
+++ const double b = *bPtr++;
+++ *cPtr++ = (a < b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_64f_x2_min_64f_generic(double* cVector, const double* aVector,
++- const double* bVector, unsigned int num_points)
+++static inline void volk_64f_x2_min_64f_generic(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- double* cPtr = cVector;
++- const double* aPtr = aVector;
++- const double* bPtr= bVector;
++- unsigned int number = 0;
++-
++- for(number = 0; number < num_points; number++){
++- const double a = *aPtr++;
++- const double b = *bPtr++;
++- *cPtr++ = ( a < b ? a : b);
++- }
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ const double a = *aPtr++;
+++ const double b = *bPtr++;
+++ *cPtr++ = (a < b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -222,38 +227,39 @@ volk_64f_x2_min_64f_generic(double* cVector, const double* aVector,
++ #ifdef LV_HAVE_AVX512F
++ #include <immintrin.h>
++
++-static inline void
++-volk_64f_x2_min_64f_u_avx512f(double* cVector, const double* aVector,
++- const double* bVector, unsigned int num_points)
+++static inline void volk_64f_x2_min_64f_u_avx512f(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int eigthPoints = num_points / 8;
+++ unsigned int number = 0;
+++ const unsigned int eigthPoints = num_points / 8;
++
++- double* cPtr = cVector;
++- const double* aPtr = aVector;
++- const double* bPtr= bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m512d aVal, bVal, cVal;
++- for(;number < eigthPoints; number++){
+++ __m512d aVal, bVal, cVal;
+++ for (; number < eigthPoints; number++) {
++
++- aVal = _mm512_loadu_pd(aPtr);
++- bVal = _mm512_loadu_pd(bPtr);
+++ aVal = _mm512_loadu_pd(aPtr);
+++ bVal = _mm512_loadu_pd(bPtr);
++
++- cVal = _mm512_min_pd(aVal, bVal);
+++ cVal = _mm512_min_pd(aVal, bVal);
++
++- _mm512_storeu_pd(cPtr,cVal); // Store the results back into the C container
+++ _mm512_storeu_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 8;
++- bPtr += 8;
++- cPtr += 8;
++- }
+++ aPtr += 8;
+++ bPtr += 8;
+++ cPtr += 8;
+++ }
++
++- number = eigthPoints * 8;
++- for(;number < num_points; number++){
++- const double a = *aPtr++;
++- const double b = *bPtr++;
++- *cPtr++ = ( a < b ? a : b);
++- }
+++ number = eigthPoints * 8;
+++ for (; number < num_points; number++) {
+++ const double a = *aPtr++;
+++ const double b = *bPtr++;
+++ *cPtr++ = (a < b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX512F */
++
++@@ -261,38 +267,39 @@ volk_64f_x2_min_64f_u_avx512f(double* cVector, const double* aVector,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_64f_x2_min_64f_u_avx(double* cVector, const double* aVector,
++- const double* bVector, unsigned int num_points)
+++static inline void volk_64f_x2_min_64f_u_avx(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
++
++- double* cPtr = cVector;
++- const double* aPtr = aVector;
++- const double* bPtr= bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m256d aVal, bVal, cVal;
++- for(;number < quarterPoints; number++){
+++ __m256d aVal, bVal, cVal;
+++ for (; number < quarterPoints; number++) {
++
++- aVal = _mm256_loadu_pd(aPtr);
++- bVal = _mm256_loadu_pd(bPtr);
+++ aVal = _mm256_loadu_pd(aPtr);
+++ bVal = _mm256_loadu_pd(bPtr);
++
++- cVal = _mm256_min_pd(aVal, bVal);
+++ cVal = _mm256_min_pd(aVal, bVal);
++
++- _mm256_storeu_pd(cPtr,cVal); // Store the results back into the C container
+++ _mm256_storeu_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- for(;number < num_points; number++){
++- const double a = *aPtr++;
++- const double b = *bPtr++;
++- *cPtr++ = ( a < b ? a : b);
++- }
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ const double a = *aPtr++;
+++ const double b = *bPtr++;
+++ *cPtr++ = (a < b ? a : b);
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++diff --git a/kernels/volk/volk_64f_x2_multiply_64f.h b/kernels/volk/volk_64f_x2_multiply_64f.h
++index 6fa9e8e..39a155d 100644
++--- a/kernels/volk/volk_64f_x2_multiply_64f.h
+++++ b/kernels/volk/volk_64f_x2_multiply_64f.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_64f_x2_multiply_64f(float* cVector, const float* aVector, const float* bVector, unsigned int num_points)
++- * \endcode
+++ * void volk_64f_x2_multiply_64f(float* cVector, const float* aVector, const float*
+++ * bVector, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: First input vector.
++@@ -76,18 +76,19 @@
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_64f_x2_multiply_64f_generic(double *cVector, const double *aVector,
++- const double *bVector, unsigned int num_points)
+++static inline void volk_64f_x2_multiply_64f_generic(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- double *cPtr = cVector;
++- const double *aPtr = aVector;
++- const double *bPtr = bVector;
++- unsigned int number = 0;
++-
++- for (number = 0; number < num_points; number++) {
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
+++ unsigned int number = 0;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++@@ -100,35 +101,36 @@ volk_64f_x2_multiply_64f_generic(double *cVector, const double *aVector,
++
++ #include <emmintrin.h>
++
++-static inline void
++-volk_64f_x2_multiply_64f_u_sse2(double *cVector, const double *aVector,
++- const double *bVector, unsigned int num_points)
+++static inline void volk_64f_x2_multiply_64f_u_sse2(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int half_points = num_points / 2;
+++ unsigned int number = 0;
+++ const unsigned int half_points = num_points / 2;
++
++- double *cPtr = cVector;
++- const double *aPtr = aVector;
++- const double *bPtr = bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m128d aVal, bVal, cVal;
++- for (; number < half_points; number++) {
++- aVal = _mm_loadu_pd(aPtr);
++- bVal = _mm_loadu_pd(bPtr);
+++ __m128d aVal, bVal, cVal;
+++ for (; number < half_points; number++) {
+++ aVal = _mm_loadu_pd(aPtr);
+++ bVal = _mm_loadu_pd(bPtr);
++
++- cVal = _mm_mul_pd(aVal, bVal);
+++ cVal = _mm_mul_pd(aVal, bVal);
++
++- _mm_storeu_pd(cPtr, cVal); // Store the results back into the C container
+++ _mm_storeu_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 2;
++- bPtr += 2;
++- cPtr += 2;
++- }
+++ aPtr += 2;
+++ bPtr += 2;
+++ cPtr += 2;
+++ }
++
++- number = half_points * 2;
++- for (; number < num_points; number++) {
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ number = half_points * 2;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE2 */
++@@ -138,36 +140,37 @@ volk_64f_x2_multiply_64f_u_sse2(double *cVector, const double *aVector,
++
++ #include <immintrin.h>
++
++-static inline void
++-volk_64f_x2_multiply_64f_u_avx(double *cVector, const double *aVector,
++- const double *bVector, unsigned int num_points)
+++static inline void volk_64f_x2_multiply_64f_u_avx(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarter_points = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarter_points = num_points / 4;
++
++- double *cPtr = cVector;
++- const double *aPtr = aVector;
++- const double *bPtr = bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m256d aVal, bVal, cVal;
++- for (; number < quarter_points; number++) {
+++ __m256d aVal, bVal, cVal;
+++ for (; number < quarter_points; number++) {
++
++- aVal = _mm256_loadu_pd(aPtr);
++- bVal = _mm256_loadu_pd(bPtr);
+++ aVal = _mm256_loadu_pd(aPtr);
+++ bVal = _mm256_loadu_pd(bPtr);
++
++- cVal = _mm256_mul_pd(aVal, bVal);
+++ cVal = _mm256_mul_pd(aVal, bVal);
++
++- _mm256_storeu_pd(cPtr, cVal); // Store the results back into the C container
+++ _mm256_storeu_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarter_points * 4;
++- for (; number < num_points; number++) {
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ number = quarter_points * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++@@ -180,35 +183,36 @@ volk_64f_x2_multiply_64f_u_avx(double *cVector, const double *aVector,
++
++ #include <emmintrin.h>
++
++-static inline void
++-volk_64f_x2_multiply_64f_a_sse2(double *cVector, const double *aVector,
++- const double *bVector, unsigned int num_points)
+++static inline void volk_64f_x2_multiply_64f_a_sse2(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int half_points = num_points / 2;
+++ unsigned int number = 0;
+++ const unsigned int half_points = num_points / 2;
++
++- double *cPtr = cVector;
++- const double *aPtr = aVector;
++- const double *bPtr = bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m128d aVal, bVal, cVal;
++- for (; number < half_points; number++) {
++- aVal = _mm_load_pd(aPtr);
++- bVal = _mm_load_pd(bPtr);
+++ __m128d aVal, bVal, cVal;
+++ for (; number < half_points; number++) {
+++ aVal = _mm_load_pd(aPtr);
+++ bVal = _mm_load_pd(bPtr);
++
++- cVal = _mm_mul_pd(aVal, bVal);
+++ cVal = _mm_mul_pd(aVal, bVal);
++
++- _mm_store_pd(cPtr, cVal); // Store the results back into the C container
+++ _mm_store_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 2;
++- bPtr += 2;
++- cPtr += 2;
++- }
+++ aPtr += 2;
+++ bPtr += 2;
+++ cPtr += 2;
+++ }
++
++- number = half_points * 2;
++- for (; number < num_points; number++) {
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ number = half_points * 2;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_SSE2 */
++@@ -218,36 +222,37 @@ volk_64f_x2_multiply_64f_a_sse2(double *cVector, const double *aVector,
++
++ #include <immintrin.h>
++
++-static inline void
++-volk_64f_x2_multiply_64f_a_avx(double *cVector, const double *aVector,
++- const double *bVector, unsigned int num_points)
+++static inline void volk_64f_x2_multiply_64f_a_avx(double* cVector,
+++ const double* aVector,
+++ const double* bVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarter_points = num_points / 4;
+++ unsigned int number = 0;
+++ const unsigned int quarter_points = num_points / 4;
++
++- double *cPtr = cVector;
++- const double *aPtr = aVector;
++- const double *bPtr = bVector;
+++ double* cPtr = cVector;
+++ const double* aPtr = aVector;
+++ const double* bPtr = bVector;
++
++- __m256d aVal, bVal, cVal;
++- for (; number < quarter_points; number++) {
+++ __m256d aVal, bVal, cVal;
+++ for (; number < quarter_points; number++) {
++
++- aVal = _mm256_load_pd(aPtr);
++- bVal = _mm256_load_pd(bPtr);
+++ aVal = _mm256_load_pd(aPtr);
+++ bVal = _mm256_load_pd(bPtr);
++
++- cVal = _mm256_mul_pd(aVal, bVal);
+++ cVal = _mm256_mul_pd(aVal, bVal);
++
++- _mm256_store_pd(cPtr, cVal); // Store the results back into the C container
+++ _mm256_store_pd(cPtr, cVal); // Store the results back into the C container
++
++- aPtr += 4;
++- bPtr += 4;
++- cPtr += 4;
++- }
+++ aPtr += 4;
+++ bPtr += 4;
+++ cPtr += 4;
+++ }
++
++- number = quarter_points * 4;
++- for (; number < num_points; number++) {
++- *cPtr++ = (*aPtr++) * (*bPtr++);
++- }
+++ number = quarter_points * 4;
+++ for (; number < num_points; number++) {
+++ *cPtr++ = (*aPtr++) * (*bPtr++);
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX */
++diff --git a/kernels/volk/volk_64u_byteswap.h b/kernels/volk/volk_64u_byteswap.h
++index 96e0661..38621a4 100644
++--- a/kernels/volk/volk_64u_byteswap.h
+++++ b/kernels/volk/volk_64u_byteswap.h
++@@ -72,71 +72,77 @@
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_64u_byteswap_u_sse2(uint64_t* intsToSwap, unsigned int num_points){
+++static inline void volk_64u_byteswap_u_sse2(uint64_t* intsToSwap, unsigned int num_points)
+++{
++ uint32_t* inputPtr = (uint32_t*)intsToSwap;
++ __m128i input, byte1, byte2, byte3, byte4, output;
++ __m128i byte2mask = _mm_set1_epi32(0x00FF0000);
++ __m128i byte3mask = _mm_set1_epi32(0x0000FF00);
++ uint64_t number = 0;
++ const unsigned int halfPoints = num_points / 2;
++- for(;number < halfPoints; number++){
++- // Load the 32t values, increment inputPtr later since we're doing it in-place.
++- input = _mm_loadu_si128((__m128i*)inputPtr);
++-
++- // Do the four shifts
++- byte1 = _mm_slli_epi32(input, 24);
++- byte2 = _mm_slli_epi32(input, 8);
++- byte3 = _mm_srli_epi32(input, 8);
++- byte4 = _mm_srli_epi32(input, 24);
++- // Or bytes together
++- output = _mm_or_si128(byte1, byte4);
++- byte2 = _mm_and_si128(byte2, byte2mask);
++- output = _mm_or_si128(output, byte2);
++- byte3 = _mm_and_si128(byte3, byte3mask);
++- output = _mm_or_si128(output, byte3);
++-
++- // Reorder the two words
++- output = _mm_shuffle_epi32(output, _MM_SHUFFLE(2, 3, 0, 1));
++-
++- // Store the results
++- _mm_storeu_si128((__m128i*)inputPtr, output);
++- inputPtr += 4;
+++ for (; number < halfPoints; number++) {
+++ // Load the 32t values, increment inputPtr later since we're doing it in-place.
+++ input = _mm_loadu_si128((__m128i*)inputPtr);
+++
+++ // Do the four shifts
+++ byte1 = _mm_slli_epi32(input, 24);
+++ byte2 = _mm_slli_epi32(input, 8);
+++ byte3 = _mm_srli_epi32(input, 8);
+++ byte4 = _mm_srli_epi32(input, 24);
+++ // Or bytes together
+++ output = _mm_or_si128(byte1, byte4);
+++ byte2 = _mm_and_si128(byte2, byte2mask);
+++ output = _mm_or_si128(output, byte2);
+++ byte3 = _mm_and_si128(byte3, byte3mask);
+++ output = _mm_or_si128(output, byte3);
+++
+++ // Reorder the two words
+++ output = _mm_shuffle_epi32(output, _MM_SHUFFLE(2, 3, 0, 1));
+++
+++ // Store the results
+++ _mm_storeu_si128((__m128i*)inputPtr, output);
+++ inputPtr += 4;
++ }
++
++ // Byteswap any remaining points:
++- number = halfPoints*2;
++- for(; number < num_points; number++){
++- uint32_t output1 = *inputPtr;
++- uint32_t output2 = inputPtr[1];
+++ number = halfPoints * 2;
+++ for (; number < num_points; number++) {
+++ uint32_t output1 = *inputPtr;
+++ uint32_t output2 = inputPtr[1];
++
++- output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) | ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));
+++ output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) |
+++ ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));
++
++- output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) | ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));
+++ output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) |
+++ ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));
++
++- *inputPtr++ = output2;
++- *inputPtr++ = output1;
+++ *inputPtr++ = output2;
+++ *inputPtr++ = output1;
++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++
++
++-
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_64u_byteswap_generic(uint64_t* intsToSwap, unsigned int num_points){
++- uint32_t* inputPtr = (uint32_t*)intsToSwap;
++- unsigned int point;
++- for(point = 0; point < num_points; point++){
++- uint32_t output1 = *inputPtr;
++- uint32_t output2 = inputPtr[1];
+++static inline void volk_64u_byteswap_generic(uint64_t* intsToSwap,
+++ unsigned int num_points)
+++{
+++ uint32_t* inputPtr = (uint32_t*)intsToSwap;
+++ unsigned int point;
+++ for (point = 0; point < num_points; point++) {
+++ uint32_t output1 = *inputPtr;
+++ uint32_t output2 = inputPtr[1];
++
++- output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) | ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));
+++ output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) |
+++ ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));
++
++- output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) | ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));
+++ output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) |
+++ ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));
++
++- *inputPtr++ = output2;
++- *inputPtr++ = output1;
++- }
+++ *inputPtr++ = output2;
+++ *inputPtr++ = output1;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -144,47 +150,47 @@ static inline void volk_64u_byteswap_generic(uint64_t* intsToSwap, unsigned int
++ #include <immintrin.h>
++ static inline void volk_64u_byteswap_a_avx2(uint64_t* intsToSwap, unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int nPerSet = 4;
++- const uint64_t nSets = num_points / nPerSet;
+++ unsigned int number = 0;
++
++- uint32_t* inputPtr = (uint32_t*)intsToSwap;
+++ const unsigned int nPerSet = 4;
+++ const uint64_t nSets = num_points / nPerSet;
++
++- const uint8_t shuffleVector[32] = { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8, 23, 22, 21, 20, 19, 18, 17, 16, 31, 30, 29, 28, 27, 26, 25, 24 };
+++ uint32_t* inputPtr = (uint32_t*)intsToSwap;
++
++- const __m256i myShuffle = _mm256_loadu_si256((__m256i*) &shuffleVector[0]);
+++ const uint8_t shuffleVector[32] = { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13,
+++ 12, 11, 10, 9, 8, 23, 22, 21, 20, 19, 18,
+++ 17, 16, 31, 30, 29, 28, 27, 26, 25, 24 };
++
++- for ( ;number < nSets; number++ ) {
+++ const __m256i myShuffle = _mm256_loadu_si256((__m256i*)&shuffleVector[0]);
++
++- // Load the 32t values, increment inputPtr later since we're doing it in-place.
++- const __m256i input = _mm256_load_si256((__m256i*)inputPtr);
++- const __m256i output = _mm256_shuffle_epi8(input, myShuffle);
+++ for (; number < nSets; number++) {
++
++- // Store the results
++- _mm256_store_si256((__m256i*)inputPtr, output);
+++ // Load the 32t values, increment inputPtr later since we're doing it in-place.
+++ const __m256i input = _mm256_load_si256((__m256i*)inputPtr);
+++ const __m256i output = _mm256_shuffle_epi8(input, myShuffle);
++
++- /* inputPtr is 32bit so increment twice */
++- inputPtr += 2 * nPerSet;
++- }
++- _mm256_zeroupper();
+++ // Store the results
+++ _mm256_store_si256((__m256i*)inputPtr, output);
++
++- // Byteswap any remaining points:
++- for(number = nSets * nPerSet; number < num_points; ++number ) {
++- uint32_t output1 = *inputPtr;
++- uint32_t output2 = inputPtr[1];
++- uint32_t out1 = ((((output1) >> 24) & 0x000000ff) |
++- (((output1) >> 8) & 0x0000ff00) |
++- (((output1) << 8) & 0x00ff0000) |
++- (((output1) << 24) & 0xff000000) );
+++ /* inputPtr is 32bit so increment twice */
+++ inputPtr += 2 * nPerSet;
+++ }
+++ _mm256_zeroupper();
++
++- uint32_t out2 = ((((output2) >> 24) & 0x000000ff) |
++- (((output2) >> 8) & 0x0000ff00) |
++- (((output2) << 8) & 0x00ff0000) |
++- (((output2) << 24) & 0xff000000) );
++- *inputPtr++ = out2;
++- *inputPtr++ = out1;
++- }
+++ // Byteswap any remaining points:
+++ for (number = nSets * nPerSet; number < num_points; ++number) {
+++ uint32_t output1 = *inputPtr;
+++ uint32_t output2 = inputPtr[1];
+++ uint32_t out1 =
+++ ((((output1) >> 24) & 0x000000ff) | (((output1) >> 8) & 0x0000ff00) |
+++ (((output1) << 8) & 0x00ff0000) | (((output1) << 24) & 0xff000000));
+++
+++ uint32_t out2 =
+++ ((((output2) >> 24) & 0x000000ff) | (((output2) >> 8) & 0x0000ff00) |
+++ (((output2) << 8) & 0x00ff0000) | (((output2) << 24) & 0xff000000));
+++ *inputPtr++ = out2;
+++ *inputPtr++ = out1;
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 */
++@@ -192,48 +198,47 @@ static inline void volk_64u_byteswap_a_avx2(uint64_t* intsToSwap, unsigned int n
++
++ #if LV_HAVE_SSSE3
++ #include <tmmintrin.h>
++-static inline void volk_64u_byteswap_a_ssse3(uint64_t* intsToSwap, unsigned int num_points)
+++static inline void volk_64u_byteswap_a_ssse3(uint64_t* intsToSwap,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
+++ unsigned int number = 0;
++
++- const unsigned int nPerSet = 2;
++- const uint64_t nSets = num_points / nPerSet;
+++ const unsigned int nPerSet = 2;
+++ const uint64_t nSets = num_points / nPerSet;
++
++- uint32_t* inputPtr = (uint32_t*)intsToSwap;
++-
++- uint8_t shuffleVector[16] = { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
+++ uint32_t* inputPtr = (uint32_t*)intsToSwap;
++
++- const __m128i myShuffle = _mm_loadu_si128((__m128i*) &shuffleVector);
+++ uint8_t shuffleVector[16] = { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
++
++- for ( ;number < nSets; number++ ) {
+++ const __m128i myShuffle = _mm_loadu_si128((__m128i*)&shuffleVector);
++
++- // Load the 32t values, increment inputPtr later since we're doing it in-place.
++- const __m128i input = _mm_load_si128((__m128i*)inputPtr);
++- const __m128i output = _mm_shuffle_epi8(input,myShuffle);
+++ for (; number < nSets; number++) {
++
++- // Store the results
++- _mm_store_si128((__m128i*)inputPtr, output);
+++ // Load the 32t values, increment inputPtr later since we're doing it in-place.
+++ const __m128i input = _mm_load_si128((__m128i*)inputPtr);
+++ const __m128i output = _mm_shuffle_epi8(input, myShuffle);
++
++- /* inputPtr is 32bit so increment twice */
++- inputPtr += 2 * nPerSet;
++- }
+++ // Store the results
+++ _mm_store_si128((__m128i*)inputPtr, output);
++
++- // Byteswap any remaining points:
++- for(number = nSets * nPerSet; number < num_points; ++number ) {
++- uint32_t output1 = *inputPtr;
++- uint32_t output2 = inputPtr[1];
++- uint32_t out1 = ((((output1) >> 24) & 0x000000ff) |
++- (((output1) >> 8) & 0x0000ff00) |
++- (((output1) << 8) & 0x00ff0000) |
++- (((output1) << 24) & 0xff000000) );
+++ /* inputPtr is 32bit so increment twice */
+++ inputPtr += 2 * nPerSet;
+++ }
++
++- uint32_t out2 = ((((output2) >> 24) & 0x000000ff) |
++- (((output2) >> 8) & 0x0000ff00) |
++- (((output2) << 8) & 0x00ff0000) |
++- (((output2) << 24) & 0xff000000) );
++- *inputPtr++ = out2;
++- *inputPtr++ = out1;
++- }
+++ // Byteswap any remaining points:
+++ for (number = nSets * nPerSet; number < num_points; ++number) {
+++ uint32_t output1 = *inputPtr;
+++ uint32_t output2 = inputPtr[1];
+++ uint32_t out1 =
+++ ((((output1) >> 24) & 0x000000ff) | (((output1) >> 8) & 0x0000ff00) |
+++ (((output1) << 8) & 0x00ff0000) | (((output1) << 24) & 0xff000000));
+++
+++ uint32_t out2 =
+++ ((((output2) >> 24) & 0x000000ff) | (((output2) >> 8) & 0x0000ff00) |
+++ (((output2) << 8) & 0x00ff0000) | (((output2) << 24) & 0xff000000));
+++ *inputPtr++ = out2;
+++ *inputPtr++ = out1;
+++ }
++ }
++ #endif /* LV_HAVE_SSSE3 */
++
++@@ -241,86 +246,90 @@ static inline void volk_64u_byteswap_a_ssse3(uint64_t* intsToSwap, unsigned int
++ #ifdef LV_HAVE_NEONV8
++ #include <arm_neon.h>
++
++-static inline void volk_64u_byteswap_neonv8(uint64_t* intsToSwap, unsigned int num_points){
++- uint32_t* inputPtr = (uint32_t*)intsToSwap;
++- const unsigned int n4points = num_points / 4;
++- uint8x16x2_t input;
++- uint8x16_t idx = { 7,6,5,4, 3,2,1,0, 15,14,13,12, 11,10,9,8 };
++-
++- unsigned int number = 0;
++- for(number = 0; number < n4points; ++number){
++- __VOLK_PREFETCH(inputPtr+8);
++- input = vld2q_u8((uint8_t*) inputPtr);
++- input.val[0] = vqtbl1q_u8(input.val[0], idx);
++- input.val[1] = vqtbl1q_u8(input.val[1], idx);
++- vst2q_u8((uint8_t*) inputPtr, input);
++-
++- inputPtr += 8;
++- }
++-
++- for(number = n4points * 4; number < num_points; ++number){
++- uint32_t output1 = *inputPtr;
++- uint32_t output2 = inputPtr[1];
+++static inline void volk_64u_byteswap_neonv8(uint64_t* intsToSwap, unsigned int num_points)
+++{
+++ uint32_t* inputPtr = (uint32_t*)intsToSwap;
+++ const unsigned int n4points = num_points / 4;
+++ uint8x16x2_t input;
+++ uint8x16_t idx = { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
+++
+++ unsigned int number = 0;
+++ for (number = 0; number < n4points; ++number) {
+++ __VOLK_PREFETCH(inputPtr + 8);
+++ input = vld2q_u8((uint8_t*)inputPtr);
+++ input.val[0] = vqtbl1q_u8(input.val[0], idx);
+++ input.val[1] = vqtbl1q_u8(input.val[1], idx);
+++ vst2q_u8((uint8_t*)inputPtr, input);
+++
+++ inputPtr += 8;
+++ }
++
++- output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) | ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));
++- output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) | ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));
+++ for (number = n4points * 4; number < num_points; ++number) {
+++ uint32_t output1 = *inputPtr;
+++ uint32_t output2 = inputPtr[1];
++
++- *inputPtr++ = output2;
++- *inputPtr++ = output1;
++- }
+++ output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) |
+++ ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));
+++ output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) |
+++ ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));
++
+++ *inputPtr++ = output2;
+++ *inputPtr++ = output1;
+++ }
++ }
++ #else
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void volk_64u_byteswap_neon(uint64_t* intsToSwap, unsigned int num_points){
++- uint32_t* inputPtr = (uint32_t*)intsToSwap;
++- unsigned int number = 0;
++- unsigned int n8points = num_points / 4;
++-
++- uint8x8x4_t input_table;
++- uint8x8_t int_lookup01, int_lookup23, int_lookup45, int_lookup67;
++- uint8x8_t swapped_int01, swapped_int23, swapped_int45, swapped_int67;
++-
++- /* these magic numbers are used as byte-indices in the LUT.
++- they are pre-computed to save time. A simple C program
++- can calculate them; for example for lookup01:
++- uint8_t chars[8] = {24, 16, 8, 0, 25, 17, 9, 1};
++- for(ii=0; ii < 8; ++ii) {
++- index += ((uint64_t)(*(chars+ii))) << (ii*8);
+++static inline void volk_64u_byteswap_neon(uint64_t* intsToSwap, unsigned int num_points)
+++{
+++ uint32_t* inputPtr = (uint32_t*)intsToSwap;
+++ unsigned int number = 0;
+++ unsigned int n8points = num_points / 4;
+++
+++ uint8x8x4_t input_table;
+++ uint8x8_t int_lookup01, int_lookup23, int_lookup45, int_lookup67;
+++ uint8x8_t swapped_int01, swapped_int23, swapped_int45, swapped_int67;
+++
+++ /* these magic numbers are used as byte-indices in the LUT.
+++ they are pre-computed to save time. A simple C program
+++ can calculate them; for example for lookup01:
+++ uint8_t chars[8] = {24, 16, 8, 0, 25, 17, 9, 1};
+++ for(ii=0; ii < 8; ++ii) {
+++ index += ((uint64_t)(*(chars+ii))) << (ii*8);
+++ }
+++ */
+++ int_lookup01 = vcreate_u8(2269495096316185);
+++ int_lookup23 = vcreate_u8(146949840772469531);
+++ int_lookup45 = vcreate_u8(291630186448622877);
+++ int_lookup67 = vcreate_u8(436310532124776223);
+++
+++ for (number = 0; number < n8points; ++number) {
+++ input_table = vld4_u8((uint8_t*)inputPtr);
+++ swapped_int01 = vtbl4_u8(input_table, int_lookup01);
+++ swapped_int23 = vtbl4_u8(input_table, int_lookup23);
+++ swapped_int45 = vtbl4_u8(input_table, int_lookup45);
+++ swapped_int67 = vtbl4_u8(input_table, int_lookup67);
+++ vst1_u8((uint8_t*)inputPtr, swapped_int01);
+++ vst1_u8((uint8_t*)(inputPtr + 2), swapped_int23);
+++ vst1_u8((uint8_t*)(inputPtr + 4), swapped_int45);
+++ vst1_u8((uint8_t*)(inputPtr + 6), swapped_int67);
+++
+++ inputPtr += 4;
++ }
++- */
++- int_lookup01 = vcreate_u8(2269495096316185);
++- int_lookup23 = vcreate_u8(146949840772469531);
++- int_lookup45 = vcreate_u8(291630186448622877);
++- int_lookup67 = vcreate_u8(436310532124776223);
++-
++- for(number = 0; number < n8points; ++number){
++- input_table = vld4_u8((uint8_t*) inputPtr);
++- swapped_int01 = vtbl4_u8(input_table, int_lookup01);
++- swapped_int23 = vtbl4_u8(input_table, int_lookup23);
++- swapped_int45 = vtbl4_u8(input_table, int_lookup45);
++- swapped_int67 = vtbl4_u8(input_table, int_lookup67);
++- vst1_u8((uint8_t*) inputPtr, swapped_int01);
++- vst1_u8((uint8_t*) (inputPtr+2), swapped_int23);
++- vst1_u8((uint8_t*) (inputPtr+4), swapped_int45);
++- vst1_u8((uint8_t*) (inputPtr+6), swapped_int67);
++-
++- inputPtr += 4;
++- }
++-
++- for(number = n8points * 4; number < num_points; ++number){
++- uint32_t output1 = *inputPtr;
++- uint32_t output2 = inputPtr[1];
++-
++- output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) | ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));
++- output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) | ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));
++-
++- *inputPtr++ = output2;
++- *inputPtr++ = output1;
++- }
++
+++ for (number = n8points * 4; number < num_points; ++number) {
+++ uint32_t output1 = *inputPtr;
+++ uint32_t output2 = inputPtr[1];
+++
+++ output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) |
+++ ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));
+++ output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) |
+++ ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));
+++
+++ *inputPtr++ = output2;
+++ *inputPtr++ = output1;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++ #endif
++@@ -336,49 +345,52 @@ static inline void volk_64u_byteswap_neon(uint64_t* intsToSwap, unsigned int num
++ #ifdef LV_HAVE_SSE2
++ #include <emmintrin.h>
++
++-static inline void volk_64u_byteswap_a_sse2(uint64_t* intsToSwap, unsigned int num_points){
+++static inline void volk_64u_byteswap_a_sse2(uint64_t* intsToSwap, unsigned int num_points)
+++{
++ uint32_t* inputPtr = (uint32_t*)intsToSwap;
++ __m128i input, byte1, byte2, byte3, byte4, output;
++ __m128i byte2mask = _mm_set1_epi32(0x00FF0000);
++ __m128i byte3mask = _mm_set1_epi32(0x0000FF00);
++ uint64_t number = 0;
++ const unsigned int halfPoints = num_points / 2;
++- for(;number < halfPoints; number++){
++- // Load the 32t values, increment inputPtr later since we're doing it in-place.
++- input = _mm_load_si128((__m128i*)inputPtr);
++-
++- // Do the four shifts
++- byte1 = _mm_slli_epi32(input, 24);
++- byte2 = _mm_slli_epi32(input, 8);
++- byte3 = _mm_srli_epi32(input, 8);
++- byte4 = _mm_srli_epi32(input, 24);
++- // Or bytes together
++- output = _mm_or_si128(byte1, byte4);
++- byte2 = _mm_and_si128(byte2, byte2mask);
++- output = _mm_or_si128(output, byte2);
++- byte3 = _mm_and_si128(byte3, byte3mask);
++- output = _mm_or_si128(output, byte3);
++-
++- // Reorder the two words
++- output = _mm_shuffle_epi32(output, _MM_SHUFFLE(2, 3, 0, 1));
++-
++- // Store the results
++- _mm_store_si128((__m128i*)inputPtr, output);
++- inputPtr += 4;
+++ for (; number < halfPoints; number++) {
+++ // Load the 32t values, increment inputPtr later since we're doing it in-place.
+++ input = _mm_load_si128((__m128i*)inputPtr);
+++
+++ // Do the four shifts
+++ byte1 = _mm_slli_epi32(input, 24);
+++ byte2 = _mm_slli_epi32(input, 8);
+++ byte3 = _mm_srli_epi32(input, 8);
+++ byte4 = _mm_srli_epi32(input, 24);
+++ // Or bytes together
+++ output = _mm_or_si128(byte1, byte4);
+++ byte2 = _mm_and_si128(byte2, byte2mask);
+++ output = _mm_or_si128(output, byte2);
+++ byte3 = _mm_and_si128(byte3, byte3mask);
+++ output = _mm_or_si128(output, byte3);
+++
+++ // Reorder the two words
+++ output = _mm_shuffle_epi32(output, _MM_SHUFFLE(2, 3, 0, 1));
+++
+++ // Store the results
+++ _mm_store_si128((__m128i*)inputPtr, output);
+++ inputPtr += 4;
++ }
++
++ // Byteswap any remaining points:
++- number = halfPoints*2;
++- for(; number < num_points; number++){
++- uint32_t output1 = *inputPtr;
++- uint32_t output2 = inputPtr[1];
+++ number = halfPoints * 2;
+++ for (; number < num_points; number++) {
+++ uint32_t output1 = *inputPtr;
+++ uint32_t output2 = inputPtr[1];
++
++- output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) | ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));
+++ output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) |
+++ ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));
++
++- output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) | ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));
+++ output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) |
+++ ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));
++
++- *inputPtr++ = output2;
++- *inputPtr++ = output1;
+++ *inputPtr++ = output2;
+++ *inputPtr++ = output1;
++ }
++ }
++ #endif /* LV_HAVE_SSE2 */
++@@ -387,46 +399,46 @@ static inline void volk_64u_byteswap_a_sse2(uint64_t* intsToSwap, unsigned int n
++ #include <immintrin.h>
++ static inline void volk_64u_byteswap_u_avx2(uint64_t* intsToSwap, unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int nPerSet = 4;
++- const uint64_t nSets = num_points / nPerSet;
++-
++- uint32_t* inputPtr = (uint32_t*)intsToSwap;
++-
++- const uint8_t shuffleVector[32] = { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8, 23, 22, 21, 20, 19, 18, 17, 16, 31, 30, 29, 28, 27, 26, 25, 24 };
++-
++- const __m256i myShuffle = _mm256_loadu_si256((__m256i*) &shuffleVector[0]);
++-
++- for ( ;number < nSets; number++ ) {
++- // Load the 32t values, increment inputPtr later since we're doing it in-place.
++- const __m256i input = _mm256_loadu_si256((__m256i*)inputPtr);
++- const __m256i output = _mm256_shuffle_epi8(input,myShuffle);
++-
++- // Store the results
++- _mm256_storeu_si256((__m256i*)inputPtr, output);
++-
++- /* inputPtr is 32bit so increment twice */
++- inputPtr += 2 * nPerSet;
++- }
++- _mm256_zeroupper();
++-
++- // Byteswap any remaining points:
++- for(number = nSets * nPerSet; number < num_points; ++number ) {
++- uint32_t output1 = *inputPtr;
++- uint32_t output2 = inputPtr[1];
++- uint32_t out1 = ((((output1) >> 24) & 0x000000ff) |
++- (((output1) >> 8) & 0x0000ff00) |
++- (((output1) << 8) & 0x00ff0000) |
++- (((output1) << 24) & 0xff000000) );
++-
++- uint32_t out2 = ((((output2) >> 24) & 0x000000ff) |
++- (((output2) >> 8) & 0x0000ff00) |
++- (((output2) << 8) & 0x00ff0000) |
++- (((output2) << 24) & 0xff000000) );
++- *inputPtr++ = out2;
++- *inputPtr++ = out1;
++- }
+++ unsigned int number = 0;
+++
+++ const unsigned int nPerSet = 4;
+++ const uint64_t nSets = num_points / nPerSet;
+++
+++ uint32_t* inputPtr = (uint32_t*)intsToSwap;
+++
+++ const uint8_t shuffleVector[32] = { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13,
+++ 12, 11, 10, 9, 8, 23, 22, 21, 20, 19, 18,
+++ 17, 16, 31, 30, 29, 28, 27, 26, 25, 24 };
+++
+++ const __m256i myShuffle = _mm256_loadu_si256((__m256i*)&shuffleVector[0]);
+++
+++ for (; number < nSets; number++) {
+++ // Load the 32t values, increment inputPtr later since we're doing it in-place.
+++ const __m256i input = _mm256_loadu_si256((__m256i*)inputPtr);
+++ const __m256i output = _mm256_shuffle_epi8(input, myShuffle);
+++
+++ // Store the results
+++ _mm256_storeu_si256((__m256i*)inputPtr, output);
+++
+++ /* inputPtr is 32bit so increment twice */
+++ inputPtr += 2 * nPerSet;
+++ }
+++ _mm256_zeroupper();
+++
+++ // Byteswap any remaining points:
+++ for (number = nSets * nPerSet; number < num_points; ++number) {
+++ uint32_t output1 = *inputPtr;
+++ uint32_t output2 = inputPtr[1];
+++ uint32_t out1 =
+++ ((((output1) >> 24) & 0x000000ff) | (((output1) >> 8) & 0x0000ff00) |
+++ (((output1) << 8) & 0x00ff0000) | (((output1) << 24) & 0xff000000));
+++
+++ uint32_t out2 =
+++ ((((output2) >> 24) & 0x000000ff) | (((output2) >> 8) & 0x0000ff00) |
+++ (((output2) << 8) & 0x00ff0000) | (((output2) << 24) & 0xff000000));
+++ *inputPtr++ = out2;
+++ *inputPtr++ = out1;
+++ }
++ }
++
++ #endif /* LV_HAVE_AVX2 */
++@@ -434,70 +446,71 @@ static inline void volk_64u_byteswap_u_avx2(uint64_t* intsToSwap, unsigned int n
++
++ #if LV_HAVE_SSSE3
++ #include <tmmintrin.h>
++-static inline void volk_64u_byteswap_u_ssse3(uint64_t* intsToSwap, unsigned int num_points)
+++static inline void volk_64u_byteswap_u_ssse3(uint64_t* intsToSwap,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++-
++- const unsigned int nPerSet = 2;
++- const uint64_t nSets = num_points / nPerSet;
+++ unsigned int number = 0;
++
++- uint32_t* inputPtr = (uint32_t*)intsToSwap;
+++ const unsigned int nPerSet = 2;
+++ const uint64_t nSets = num_points / nPerSet;
++
++- uint8_t shuffleVector[16] = { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
+++ uint32_t* inputPtr = (uint32_t*)intsToSwap;
++
++- const __m128i myShuffle = _mm_loadu_si128((__m128i*) &shuffleVector);
+++ uint8_t shuffleVector[16] = { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 };
++
++- for ( ;number < nSets; number++ ) {
++- // Load the 32t values, increment inputPtr later since we're doing it in-place.
++- const __m128i input = _mm_loadu_si128((__m128i*)inputPtr);
++- const __m128i output = _mm_shuffle_epi8(input,myShuffle);
+++ const __m128i myShuffle = _mm_loadu_si128((__m128i*)&shuffleVector);
++
++- // Store the results
++- _mm_storeu_si128((__m128i*)inputPtr, output);
+++ for (; number < nSets; number++) {
+++ // Load the 32t values, increment inputPtr later since we're doing it in-place.
+++ const __m128i input = _mm_loadu_si128((__m128i*)inputPtr);
+++ const __m128i output = _mm_shuffle_epi8(input, myShuffle);
++
++- /* inputPtr is 32bit so increment twice */
++- inputPtr += 2 * nPerSet;
++- }
+++ // Store the results
+++ _mm_storeu_si128((__m128i*)inputPtr, output);
++
++- // Byteswap any remaining points:
++- for(number = nSets * nPerSet; number < num_points; ++number ) {
++- uint32_t output1 = *inputPtr;
++- uint32_t output2 = inputPtr[1];
++- uint32_t out1 = ((((output1) >> 24) & 0x000000ff) |
++- (((output1) >> 8) & 0x0000ff00) |
++- (((output1) << 8) & 0x00ff0000) |
++- (((output1) << 24) & 0xff000000) );
+++ /* inputPtr is 32bit so increment twice */
+++ inputPtr += 2 * nPerSet;
+++ }
++
++- uint32_t out2 = ((((output2) >> 24) & 0x000000ff) |
++- (((output2) >> 8) & 0x0000ff00) |
++- (((output2) << 8) & 0x00ff0000) |
++- (((output2) << 24) & 0xff000000) );
++- *inputPtr++ = out2;
++- *inputPtr++ = out1;
++- }
+++ // Byteswap any remaining points:
+++ for (number = nSets * nPerSet; number < num_points; ++number) {
+++ uint32_t output1 = *inputPtr;
+++ uint32_t output2 = inputPtr[1];
+++ uint32_t out1 =
+++ ((((output1) >> 24) & 0x000000ff) | (((output1) >> 8) & 0x0000ff00) |
+++ (((output1) << 8) & 0x00ff0000) | (((output1) << 24) & 0xff000000));
+++
+++ uint32_t out2 =
+++ ((((output2) >> 24) & 0x000000ff) | (((output2) >> 8) & 0x0000ff00) |
+++ (((output2) << 8) & 0x00ff0000) | (((output2) << 24) & 0xff000000));
+++ *inputPtr++ = out2;
+++ *inputPtr++ = out1;
+++ }
++ }
++ #endif /* LV_HAVE_SSSE3 */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void volk_64u_byteswap_a_generic(uint64_t* intsToSwap, unsigned int num_points){
++- uint32_t* inputPtr = (uint32_t*)intsToSwap;
++- unsigned int point;
++- for(point = 0; point < num_points; point++){
++- uint32_t output1 = *inputPtr;
++- uint32_t output2 = inputPtr[1];
+++static inline void volk_64u_byteswap_a_generic(uint64_t* intsToSwap,
+++ unsigned int num_points)
+++{
+++ uint32_t* inputPtr = (uint32_t*)intsToSwap;
+++ unsigned int point;
+++ for (point = 0; point < num_points; point++) {
+++ uint32_t output1 = *inputPtr;
+++ uint32_t output2 = inputPtr[1];
++
++- output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) | ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));
+++ output1 = (((output1 >> 24) & 0xff) | ((output1 >> 8) & 0x0000ff00) |
+++ ((output1 << 8) & 0x00ff0000) | ((output1 << 24) & 0xff000000));
++
++- output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) | ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));
+++ output2 = (((output2 >> 24) & 0xff) | ((output2 >> 8) & 0x0000ff00) |
+++ ((output2 << 8) & 0x00ff0000) | ((output2 << 24) & 0xff000000));
++
++- *inputPtr++ = output2;
++- *inputPtr++ = output1;
++- }
+++ *inputPtr++ = output2;
+++ *inputPtr++ = output1;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++-
++ #endif /* INCLUDED_volk_64u_byteswap_a_H */
++diff --git a/kernels/volk/volk_64u_byteswappuppet_64u.h b/kernels/volk/volk_64u_byteswappuppet_64u.h
++index 2db0171..ded54ee 100644
++--- a/kernels/volk/volk_64u_byteswappuppet_64u.h
+++++ b/kernels/volk/volk_64u_byteswappuppet_64u.h
++@@ -3,87 +3,105 @@
++
++
++ #include <stdint.h>
++-#include <volk/volk_64u_byteswap.h>
++ #include <string.h>
+++#include <volk/volk_64u_byteswap.h>
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void volk_64u_byteswappuppet_64u_generic(uint64_t*output, uint64_t* intsToSwap, unsigned int num_points){
+++static inline void volk_64u_byteswappuppet_64u_generic(uint64_t* output,
+++ uint64_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_64u_byteswap_generic((uint64_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint64_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_NEONV8
++-static inline void volk_64u_byteswappuppet_64u_neonv8(uint64_t*output, uint64_t* intsToSwap, unsigned int num_points){
+++static inline void volk_64u_byteswappuppet_64u_neonv8(uint64_t* output,
+++ uint64_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_64u_byteswap_neonv8((uint64_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint64_t));
++-
++ }
++ #else
++ #ifdef LV_HAVE_NEON
++-static inline void volk_64u_byteswappuppet_64u_neon(uint64_t*output, uint64_t* intsToSwap, unsigned int num_points){
+++static inline void volk_64u_byteswappuppet_64u_neon(uint64_t* output,
+++ uint64_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_64u_byteswap_neon((uint64_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint64_t));
++-
++ }
++ #endif
++ #endif
++
++ #ifdef LV_HAVE_SSE2
++-static inline void volk_64u_byteswappuppet_64u_u_sse2(uint64_t* output, uint64_t* intsToSwap, unsigned int num_points){
+++static inline void volk_64u_byteswappuppet_64u_u_sse2(uint64_t* output,
+++ uint64_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_64u_byteswap_u_sse2((uint64_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint64_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_SSE2
++-static inline void volk_64u_byteswappuppet_64u_a_sse2(uint64_t* output, uint64_t* intsToSwap, unsigned int num_points){
+++static inline void volk_64u_byteswappuppet_64u_a_sse2(uint64_t* output,
+++ uint64_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_64u_byteswap_a_sse2((uint64_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint64_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_SSSE3
++-static inline void volk_64u_byteswappuppet_64u_u_ssse3(uint64_t* output, uint64_t* intsToSwap, unsigned int num_points){
+++static inline void volk_64u_byteswappuppet_64u_u_ssse3(uint64_t* output,
+++ uint64_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_64u_byteswap_u_ssse3((uint64_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint64_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_SSSE3
++-static inline void volk_64u_byteswappuppet_64u_a_ssse3(uint64_t* output, uint64_t* intsToSwap, unsigned int num_points){
+++static inline void volk_64u_byteswappuppet_64u_a_ssse3(uint64_t* output,
+++ uint64_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_64u_byteswap_a_ssse3((uint64_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint64_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_AVX2
++-static inline void volk_64u_byteswappuppet_64u_u_avx2(uint64_t* output, uint64_t* intsToSwap, unsigned int num_points){
+++static inline void volk_64u_byteswappuppet_64u_u_avx2(uint64_t* output,
+++ uint64_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_64u_byteswap_u_avx2((uint64_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint64_t));
++-
++ }
++ #endif
++
++ #ifdef LV_HAVE_AVX2
++-static inline void volk_64u_byteswappuppet_64u_a_avx2(uint64_t* output, uint64_t* intsToSwap, unsigned int num_points){
+++static inline void volk_64u_byteswappuppet_64u_a_avx2(uint64_t* output,
+++ uint64_t* intsToSwap,
+++ unsigned int num_points)
+++{
++
++ volk_64u_byteswap_a_avx2((uint64_t*)intsToSwap, num_points);
++ memcpy((void*)output, (void*)intsToSwap, num_points * sizeof(uint64_t));
++-
++ }
++ #endif
++
++diff --git a/kernels/volk/volk_64u_popcnt.h b/kernels/volk/volk_64u_popcnt.h
++index cbce2ec..43c2ae0 100644
++--- a/kernels/volk/volk_64u_popcnt.h
+++++ b/kernels/volk/volk_64u_popcnt.h
++@@ -60,39 +60,38 @@
++ #ifndef INCLUDED_volk_64u_popcnt_a_H
++ #define INCLUDED_volk_64u_popcnt_a_H
++
++-#include <stdio.h>
++ #include <inttypes.h>
+++#include <stdio.h>
++
++
++ #ifdef LV_HAVE_GENERIC
++
++
++-static inline void
++-volk_64u_popcnt_generic(uint64_t* ret, const uint64_t value)
+++static inline void volk_64u_popcnt_generic(uint64_t* ret, const uint64_t value)
++ {
++- //const uint32_t* valueVector = (const uint32_t*)&value;
++-
++- // This is faster than a lookup table
++- //uint32_t retVal = valueVector[0];
++- uint32_t retVal = (uint32_t)(value & 0x00000000FFFFFFFFull);
++-
++- retVal = (retVal & 0x55555555) + (retVal >> 1 & 0x55555555);
++- retVal = (retVal & 0x33333333) + (retVal >> 2 & 0x33333333);
++- retVal = (retVal + (retVal >> 4)) & 0x0F0F0F0F;
++- retVal = (retVal + (retVal >> 8));
++- retVal = (retVal + (retVal >> 16)) & 0x0000003F;
++- uint64_t retVal64 = retVal;
++-
++- //retVal = valueVector[1];
++- retVal = (uint32_t)((value & 0xFFFFFFFF00000000ull) >> 32);
++- retVal = (retVal & 0x55555555) + (retVal >> 1 & 0x55555555);
++- retVal = (retVal & 0x33333333) + (retVal >> 2 & 0x33333333);
++- retVal = (retVal + (retVal >> 4)) & 0x0F0F0F0F;
++- retVal = (retVal + (retVal >> 8));
++- retVal = (retVal + (retVal >> 16)) & 0x0000003F;
++- retVal64 += retVal;
++-
++- *ret = retVal64;
+++ // const uint32_t* valueVector = (const uint32_t*)&value;
+++
+++ // This is faster than a lookup table
+++ // uint32_t retVal = valueVector[0];
+++ uint32_t retVal = (uint32_t)(value & 0x00000000FFFFFFFFull);
+++
+++ retVal = (retVal & 0x55555555) + (retVal >> 1 & 0x55555555);
+++ retVal = (retVal & 0x33333333) + (retVal >> 2 & 0x33333333);
+++ retVal = (retVal + (retVal >> 4)) & 0x0F0F0F0F;
+++ retVal = (retVal + (retVal >> 8));
+++ retVal = (retVal + (retVal >> 16)) & 0x0000003F;
+++ uint64_t retVal64 = retVal;
+++
+++ // retVal = valueVector[1];
+++ retVal = (uint32_t)((value & 0xFFFFFFFF00000000ull) >> 32);
+++ retVal = (retVal & 0x55555555) + (retVal >> 1 & 0x55555555);
+++ retVal = (retVal & 0x33333333) + (retVal >> 2 & 0x33333333);
+++ retVal = (retVal + (retVal >> 4)) & 0x0F0F0F0F;
+++ retVal = (retVal + (retVal >> 8));
+++ retVal = (retVal + (retVal >> 16)) & 0x0000003F;
+++ retVal64 += retVal;
+++
+++ *ret = retVal64;
++ }
++
++ #endif /*LV_HAVE_GENERIC*/
++@@ -104,7 +103,7 @@ volk_64u_popcnt_generic(uint64_t* ret, const uint64_t value)
++
++ static inline void volk_64u_popcnt_a_sse4_2(uint64_t* ret, const uint64_t value)
++ {
++- *ret = _mm_popcnt_u64(value);
+++ *ret = _mm_popcnt_u64(value);
++ }
++
++ #endif /*LV_HAVE_SSE4_2*/
++@@ -114,19 +113,19 @@ static inline void volk_64u_popcnt_a_sse4_2(uint64_t* ret, const uint64_t value)
++ #include <arm_neon.h>
++ static inline void volk_64u_popcnt_neon(uint64_t* ret, const uint64_t value)
++ {
++- uint8x8_t input_val, count8x8_val;
++- uint16x4_t count16x4_val;
++- uint32x2_t count32x2_val;
++- uint64x1_t count64x1_val;
++-
++- input_val = vld1_u8((unsigned char *) &value);
++- count8x8_val = vcnt_u8(input_val);
++- count16x4_val = vpaddl_u8(count8x8_val);
++- count32x2_val = vpaddl_u16(count16x4_val);
++- count64x1_val = vpaddl_u32(count32x2_val);
++- vst1_u64(ret, count64x1_val);
++-
++- //*ret = _mm_popcnt_u64(value);
+++ uint8x8_t input_val, count8x8_val;
+++ uint16x4_t count16x4_val;
+++ uint32x2_t count32x2_val;
+++ uint64x1_t count64x1_val;
+++
+++ input_val = vld1_u8((unsigned char*)&value);
+++ count8x8_val = vcnt_u8(input_val);
+++ count16x4_val = vpaddl_u8(count8x8_val);
+++ count32x2_val = vpaddl_u16(count16x4_val);
+++ count64x1_val = vpaddl_u32(count32x2_val);
+++ vst1_u64(ret, count64x1_val);
+++
+++ //*ret = _mm_popcnt_u64(value);
++ }
++ #endif /*LV_HAVE_NEON*/
++
++diff --git a/kernels/volk/volk_64u_popcntpuppet_64u.h b/kernels/volk/volk_64u_popcntpuppet_64u.h
++index e38ebb3..688281a 100644
++--- a/kernels/volk/volk_64u_popcntpuppet_64u.h
+++++ b/kernels/volk/volk_64u_popcntpuppet_64u.h
++@@ -23,35 +23,44 @@
++ #ifndef INCLUDED_volk_64u_popcntpuppet_64u_H
++ #define INCLUDED_volk_64u_popcntpuppet_64u_H
++
++-#include <volk/volk_64u_popcnt.h>
++ #include <stdint.h>
++ #include <string.h>
+++#include <volk/volk_64u_popcnt.h>
++
++ #ifdef LV_HAVE_GENERIC
++-static inline void volk_64u_popcntpuppet_64u_generic(uint64_t* outVector, const uint64_t* inVector, unsigned int num_points){
+++static inline void volk_64u_popcntpuppet_64u_generic(uint64_t* outVector,
+++ const uint64_t* inVector,
+++ unsigned int num_points)
+++{
++ unsigned int ii;
++- for(ii=0; ii < num_points; ++ii) {
++- volk_64u_popcnt_generic(outVector+ii, num_points );
+++ for (ii = 0; ii < num_points; ++ii) {
+++ volk_64u_popcnt_generic(outVector + ii, num_points);
++ }
++ memcpy((void*)outVector, (void*)inVector, num_points * sizeof(uint64_t));
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #if LV_HAVE_SSE4_2 && LV_HAVE_64
++-static inline void volk_64u_popcntpuppet_64u_a_sse4_2(uint64_t* outVector, const uint64_t* inVector, unsigned int num_points){
+++static inline void volk_64u_popcntpuppet_64u_a_sse4_2(uint64_t* outVector,
+++ const uint64_t* inVector,
+++ unsigned int num_points)
+++{
++ unsigned int ii;
++- for(ii=0; ii < num_points; ++ii) {
++- volk_64u_popcnt_a_sse4_2(outVector+ii, num_points );
+++ for (ii = 0; ii < num_points; ++ii) {
+++ volk_64u_popcnt_a_sse4_2(outVector + ii, num_points);
++ }
++ memcpy((void*)outVector, (void*)inVector, num_points * sizeof(uint64_t));
++ }
++ #endif /* LV_HAVE_SSE4_2 */
++
++ #ifdef LV_HAVE_NEON
++-static inline void volk_64u_popcntpuppet_64u_neon(uint64_t* outVector, const uint64_t* inVector, unsigned int num_points){
+++static inline void volk_64u_popcntpuppet_64u_neon(uint64_t* outVector,
+++ const uint64_t* inVector,
+++ unsigned int num_points)
+++{
++ unsigned int ii;
++- for(ii=0; ii < num_points; ++ii) {
++- volk_64u_popcnt_neon(outVector+ii, num_points );
+++ for (ii = 0; ii < num_points; ++ii) {
+++ volk_64u_popcnt_neon(outVector + ii, num_points);
++ }
++ memcpy((void*)outVector, (void*)inVector, num_points * sizeof(uint64_t));
++ }
++diff --git a/kernels/volk/volk_8i_convert_16i.h b/kernels/volk/volk_8i_convert_16i.h
++index 40400c3..69d8f6a 100644
++--- a/kernels/volk/volk_8i_convert_16i.h
+++++ b/kernels/volk/volk_8i_convert_16i.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_8i_convert_16i(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points)
++- * \endcode
+++ * void volk_8i_convert_16i(int16_t* outputVector, const int8_t* inputVector, unsigned int
+++ * num_points) \endcode
++ *
++ * \b Inputs
++ * \li inputVector: The input vector of 8-bit chars.
++@@ -59,32 +59,32 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8i_convert_16i_u_avx2(int16_t* outputVector, const int8_t* inputVector,
++- unsigned int num_points)
+++static inline void volk_8i_convert_16i_u_avx2(int16_t* outputVector,
+++ const int8_t* inputVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- const __m128i* inputVectorPtr = (const __m128i*)inputVector;
++- __m256i* outputVectorPtr = (__m256i*)outputVector;
++- __m128i inputVal;
++- __m256i ret;
++-
++- for(;number < sixteenthPoints; number++){
++- inputVal = _mm_loadu_si128(inputVectorPtr);
++- ret = _mm256_cvtepi8_epi16(inputVal);
++- ret = _mm256_slli_epi16(ret, 8); // Multiply by 256
++- _mm256_storeu_si256(outputVectorPtr, ret);
++-
++- outputVectorPtr++;
++- inputVectorPtr++;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] = (int16_t)(inputVector[number])*256;
++- }
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ const __m128i* inputVectorPtr = (const __m128i*)inputVector;
+++ __m256i* outputVectorPtr = (__m256i*)outputVector;
+++ __m128i inputVal;
+++ __m256i ret;
+++
+++ for (; number < sixteenthPoints; number++) {
+++ inputVal = _mm_loadu_si128(inputVectorPtr);
+++ ret = _mm256_cvtepi8_epi16(inputVal);
+++ ret = _mm256_slli_epi16(ret, 8); // Multiply by 256
+++ _mm256_storeu_si256(outputVectorPtr, ret);
+++
+++ outputVectorPtr++;
+++ inputVectorPtr++;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (int16_t)(inputVector[number]) * 256;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -92,57 +92,57 @@ volk_8i_convert_16i_u_avx2(int16_t* outputVector, const int8_t* inputVector,
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void
++-volk_8i_convert_16i_u_sse4_1(int16_t* outputVector, const int8_t* inputVector,
++- unsigned int num_points)
+++static inline void volk_8i_convert_16i_u_sse4_1(int16_t* outputVector,
+++ const int8_t* inputVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- const __m128i* inputVectorPtr = (const __m128i*)inputVector;
++- __m128i* outputVectorPtr = (__m128i*)outputVector;
++- __m128i inputVal;
++- __m128i ret;
+++ const __m128i* inputVectorPtr = (const __m128i*)inputVector;
+++ __m128i* outputVectorPtr = (__m128i*)outputVector;
+++ __m128i inputVal;
+++ __m128i ret;
++
++- for(;number < sixteenthPoints; number++){
++- inputVal = _mm_loadu_si128(inputVectorPtr);
++- ret = _mm_cvtepi8_epi16(inputVal);
++- ret = _mm_slli_epi16(ret, 8); // Multiply by 256
++- _mm_storeu_si128(outputVectorPtr, ret);
+++ for (; number < sixteenthPoints; number++) {
+++ inputVal = _mm_loadu_si128(inputVectorPtr);
+++ ret = _mm_cvtepi8_epi16(inputVal);
+++ ret = _mm_slli_epi16(ret, 8); // Multiply by 256
+++ _mm_storeu_si128(outputVectorPtr, ret);
++
++- outputVectorPtr++;
+++ outputVectorPtr++;
++
++- inputVal = _mm_srli_si128(inputVal, 8);
++- ret = _mm_cvtepi8_epi16(inputVal);
++- ret = _mm_slli_epi16(ret, 8); // Multiply by 256
++- _mm_storeu_si128(outputVectorPtr, ret);
+++ inputVal = _mm_srli_si128(inputVal, 8);
+++ ret = _mm_cvtepi8_epi16(inputVal);
+++ ret = _mm_slli_epi16(ret, 8); // Multiply by 256
+++ _mm_storeu_si128(outputVectorPtr, ret);
++
++- outputVectorPtr++;
+++ outputVectorPtr++;
++
++- inputVectorPtr++;
++- }
+++ inputVectorPtr++;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] = (int16_t)(inputVector[number])*256;
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (int16_t)(inputVector[number]) * 256;
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_8i_convert_16i_generic(int16_t* outputVector, const int8_t* inputVector,
++- unsigned int num_points)
+++static inline void volk_8i_convert_16i_generic(int16_t* outputVector,
+++ const int8_t* inputVector,
+++ unsigned int num_points)
++ {
++- int16_t* outputVectorPtr = outputVector;
++- const int8_t* inputVectorPtr = inputVector;
++- unsigned int number = 0;
+++ int16_t* outputVectorPtr = outputVector;
+++ const int8_t* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((int16_t)(*inputVectorPtr++)) * 256;
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((int16_t)(*inputVectorPtr++)) * 256;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -150,7 +150,6 @@ volk_8i_convert_16i_generic(int16_t* outputVector, const int8_t* inputVector,
++ #endif /* INCLUDED_VOLK_8s_CONVERT_16s_UNALIGNED8_H */
++
++
++-
++ #ifndef INCLUDED_volk_8i_convert_16i_a_H
++ #define INCLUDED_volk_8i_convert_16i_a_H
++
++@@ -160,32 +159,32 @@ volk_8i_convert_16i_generic(int16_t* outputVector, const int8_t* inputVector,
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8i_convert_16i_a_avx2(int16_t* outputVector, const int8_t* inputVector,
++- unsigned int num_points)
+++static inline void volk_8i_convert_16i_a_avx2(int16_t* outputVector,
+++ const int8_t* inputVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- const __m128i* inputVectorPtr = (const __m128i*)inputVector;
++- __m256i* outputVectorPtr = (__m256i*)outputVector;
++- __m128i inputVal;
++- __m256i ret;
++-
++- for(;number < sixteenthPoints; number++){
++- inputVal = _mm_load_si128(inputVectorPtr);
++- ret = _mm256_cvtepi8_epi16(inputVal);
++- ret = _mm256_slli_epi16(ret, 8); // Multiply by 256
++- _mm256_store_si256(outputVectorPtr, ret);
++-
++- outputVectorPtr++;
++- inputVectorPtr++;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] = (int16_t)(inputVector[number])*256;
++- }
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ const __m128i* inputVectorPtr = (const __m128i*)inputVector;
+++ __m256i* outputVectorPtr = (__m256i*)outputVector;
+++ __m128i inputVal;
+++ __m256i ret;
+++
+++ for (; number < sixteenthPoints; number++) {
+++ inputVal = _mm_load_si128(inputVectorPtr);
+++ ret = _mm256_cvtepi8_epi16(inputVal);
+++ ret = _mm256_slli_epi16(ret, 8); // Multiply by 256
+++ _mm256_store_si256(outputVectorPtr, ret);
+++
+++ outputVectorPtr++;
+++ inputVectorPtr++;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (int16_t)(inputVector[number]) * 256;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -193,57 +192,57 @@ volk_8i_convert_16i_a_avx2(int16_t* outputVector, const int8_t* inputVector,
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void
++-volk_8i_convert_16i_a_sse4_1(int16_t* outputVector, const int8_t* inputVector,
++- unsigned int num_points)
+++static inline void volk_8i_convert_16i_a_sse4_1(int16_t* outputVector,
+++ const int8_t* inputVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
++
++- const __m128i* inputVectorPtr = (const __m128i*)inputVector;
++- __m128i* outputVectorPtr = (__m128i*)outputVector;
++- __m128i inputVal;
++- __m128i ret;
+++ const __m128i* inputVectorPtr = (const __m128i*)inputVector;
+++ __m128i* outputVectorPtr = (__m128i*)outputVector;
+++ __m128i inputVal;
+++ __m128i ret;
++
++- for(;number < sixteenthPoints; number++){
++- inputVal = _mm_load_si128(inputVectorPtr);
++- ret = _mm_cvtepi8_epi16(inputVal);
++- ret = _mm_slli_epi16(ret, 8); // Multiply by 256
++- _mm_store_si128(outputVectorPtr, ret);
+++ for (; number < sixteenthPoints; number++) {
+++ inputVal = _mm_load_si128(inputVectorPtr);
+++ ret = _mm_cvtepi8_epi16(inputVal);
+++ ret = _mm_slli_epi16(ret, 8); // Multiply by 256
+++ _mm_store_si128(outputVectorPtr, ret);
++
++- outputVectorPtr++;
+++ outputVectorPtr++;
++
++- inputVal = _mm_srli_si128(inputVal, 8);
++- ret = _mm_cvtepi8_epi16(inputVal);
++- ret = _mm_slli_epi16(ret, 8); // Multiply by 256
++- _mm_store_si128(outputVectorPtr, ret);
+++ inputVal = _mm_srli_si128(inputVal, 8);
+++ ret = _mm_cvtepi8_epi16(inputVal);
+++ ret = _mm_slli_epi16(ret, 8); // Multiply by 256
+++ _mm_store_si128(outputVectorPtr, ret);
++
++- outputVectorPtr++;
+++ outputVectorPtr++;
++
++- inputVectorPtr++;
++- }
+++ inputVectorPtr++;
+++ }
++
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] = (int16_t)(inputVector[number])*256;
++- }
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (int16_t)(inputVector[number]) * 256;
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_8i_convert_16i_a_generic(int16_t* outputVector, const int8_t* inputVector,
++- unsigned int num_points)
+++static inline void volk_8i_convert_16i_a_generic(int16_t* outputVector,
+++ const int8_t* inputVector,
+++ unsigned int num_points)
++ {
++- int16_t* outputVectorPtr = outputVector;
++- const int8_t* inputVectorPtr = inputVector;
++- unsigned int number = 0;
+++ int16_t* outputVectorPtr = outputVector;
+++ const int8_t* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
++
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((int16_t)(*inputVectorPtr++)) * 256;
++- }
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((int16_t)(*inputVectorPtr++)) * 256;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -251,51 +250,51 @@ volk_8i_convert_16i_a_generic(int16_t* outputVector, const int8_t* inputVector,
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_8i_convert_16i_neon(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points)
+++static inline void volk_8i_convert_16i_neon(int16_t* outputVector,
+++ const int8_t* inputVector,
+++ unsigned int num_points)
++ {
++- int16_t* outputVectorPtr = outputVector;
++- const int8_t* inputVectorPtr = inputVector;
++- unsigned int number;
++- const unsigned int eighth_points = num_points / 8;
++-
++- int8x8_t input_vec ;
++- int16x8_t converted_vec;
++-
++- // NEON doesn't have a concept of 8 bit registers, so we are really
++- // dealing with the low half of 16-bit registers. Since this requires
++- // a move instruction we likely do better with ASM here.
++- for(number = 0; number < eighth_points; ++number) {
++- input_vec = vld1_s8(inputVectorPtr);
++- converted_vec = vmovl_s8(input_vec);
++- //converted_vec = vmulq_s16(converted_vec, scale_factor);
++- converted_vec = vshlq_n_s16(converted_vec, 8);
++- vst1q_s16( outputVectorPtr, converted_vec);
++-
++- inputVectorPtr += 8;
++- outputVectorPtr += 8;
++- }
++-
++- for(number = eighth_points * 8; number < num_points; number++){
++- *outputVectorPtr++ = ((int16_t)(*inputVectorPtr++)) * 256;
++- }
+++ int16_t* outputVectorPtr = outputVector;
+++ const int8_t* inputVectorPtr = inputVector;
+++ unsigned int number;
+++ const unsigned int eighth_points = num_points / 8;
+++
+++ int8x8_t input_vec;
+++ int16x8_t converted_vec;
+++
+++ // NEON doesn't have a concept of 8 bit registers, so we are really
+++ // dealing with the low half of 16-bit registers. Since this requires
+++ // a move instruction we likely do better with ASM here.
+++ for (number = 0; number < eighth_points; ++number) {
+++ input_vec = vld1_s8(inputVectorPtr);
+++ converted_vec = vmovl_s8(input_vec);
+++ // converted_vec = vmulq_s16(converted_vec, scale_factor);
+++ converted_vec = vshlq_n_s16(converted_vec, 8);
+++ vst1q_s16(outputVectorPtr, converted_vec);
+++
+++ inputVectorPtr += 8;
+++ outputVectorPtr += 8;
+++ }
+++
+++ for (number = eighth_points * 8; number < num_points; number++) {
+++ *outputVectorPtr++ = ((int16_t)(*inputVectorPtr++)) * 256;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++
++ #ifdef LV_HAVE_ORC
++-extern void
++-volk_8i_convert_16i_a_orc_impl(int16_t* outputVector, const int8_t* inputVector,
++- unsigned int num_points);
+++extern void volk_8i_convert_16i_a_orc_impl(int16_t* outputVector,
+++ const int8_t* inputVector,
+++ unsigned int num_points);
++
++-static inline void
++-volk_8i_convert_16i_u_orc(int16_t* outputVector, const int8_t* inputVector,
++- unsigned int num_points)
+++static inline void volk_8i_convert_16i_u_orc(int16_t* outputVector,
+++ const int8_t* inputVector,
+++ unsigned int num_points)
++ {
++- volk_8i_convert_16i_a_orc_impl(outputVector, inputVector, num_points);
+++ volk_8i_convert_16i_a_orc_impl(outputVector, inputVector, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++
++-
++ #endif /* INCLUDED_VOLK_8s_CONVERT_16s_ALIGNED8_H */
++diff --git a/kernels/volk/volk_8i_s32f_convert_32f.h b/kernels/volk/volk_8i_s32f_convert_32f.h
++index 97d160b..c3d5666 100644
++--- a/kernels/volk/volk_8i_s32f_convert_32f.h
+++++ b/kernels/volk/volk_8i_s32f_convert_32f.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_8i_s32f_convert_32f(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points)
++- * \endcode
+++ * void volk_8i_s32f_convert_32f(float* outputVector, const int8_t* inputVector, const
+++ * float scalar, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li inputVector: The input vector of 8-bit chars.
++@@ -60,44 +60,45 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8i_s32f_convert_32f_u_avx2(float* outputVector, const int8_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_8i_s32f_convert_32f_u_avx2(float* outputVector,
+++ const int8_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float* outputVectorPtr = outputVector;
++- const float iScalar = 1.0 / scalar;
++- __m256 invScalar = _mm256_set1_ps( iScalar );
++- const int8_t* inputVectorPtr = inputVector;
++- __m256 ret;
++- __m128i inputVal128;
++- __m256i interimVal;
++-
++- for(;number < sixteenthPoints; number++){
++- inputVal128 = _mm_loadu_si128((__m128i*)inputVectorPtr);
++-
++- interimVal = _mm256_cvtepi8_epi32(inputVal128);
++- ret = _mm256_cvtepi32_ps(interimVal);
++- ret = _mm256_mul_ps(ret, invScalar);
++- _mm256_storeu_ps(outputVectorPtr, ret);
++- outputVectorPtr += 8;
++-
++- inputVal128 = _mm_srli_si128(inputVal128, 8);
++- interimVal = _mm256_cvtepi8_epi32(inputVal128);
++- ret = _mm256_cvtepi32_ps(interimVal);
++- ret = _mm256_mul_ps(ret, invScalar);
++- _mm256_storeu_ps(outputVectorPtr, ret);
++- outputVectorPtr += 8;
++-
++- inputVectorPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] = (float)(inputVector[number]) * iScalar;
++- }
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float* outputVectorPtr = outputVector;
+++ const float iScalar = 1.0 / scalar;
+++ __m256 invScalar = _mm256_set1_ps(iScalar);
+++ const int8_t* inputVectorPtr = inputVector;
+++ __m256 ret;
+++ __m128i inputVal128;
+++ __m256i interimVal;
+++
+++ for (; number < sixteenthPoints; number++) {
+++ inputVal128 = _mm_loadu_si128((__m128i*)inputVectorPtr);
+++
+++ interimVal = _mm256_cvtepi8_epi32(inputVal128);
+++ ret = _mm256_cvtepi32_ps(interimVal);
+++ ret = _mm256_mul_ps(ret, invScalar);
+++ _mm256_storeu_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 8;
+++
+++ inputVal128 = _mm_srli_si128(inputVal128, 8);
+++ interimVal = _mm256_cvtepi8_epi32(inputVal128);
+++ ret = _mm256_cvtepi32_ps(interimVal);
+++ ret = _mm256_mul_ps(ret, invScalar);
+++ _mm256_storeu_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 8;
+++
+++ inputVectorPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (float)(inputVector[number]) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -105,80 +106,81 @@ volk_8i_s32f_convert_32f_u_avx2(float* outputVector, const int8_t* inputVector,
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void
++-volk_8i_s32f_convert_32f_u_sse4_1(float* outputVector, const int8_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_8i_s32f_convert_32f_u_sse4_1(float* outputVector,
+++ const int8_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float* outputVectorPtr = outputVector;
++- const float iScalar = 1.0 / scalar;
++- __m128 invScalar = _mm_set_ps1( iScalar );
++- const int8_t* inputVectorPtr = inputVector;
++- __m128 ret;
++- __m128i inputVal;
++- __m128i interimVal;
++-
++- for(;number < sixteenthPoints; number++){
++- inputVal = _mm_loadu_si128((__m128i*)inputVectorPtr);
++-
++- interimVal = _mm_cvtepi8_epi32(inputVal);
++- ret = _mm_cvtepi32_ps(interimVal);
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_storeu_ps(outputVectorPtr, ret);
++- outputVectorPtr += 4;
++-
++- inputVal = _mm_srli_si128(inputVal, 4);
++- interimVal = _mm_cvtepi8_epi32(inputVal);
++- ret = _mm_cvtepi32_ps(interimVal);
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_storeu_ps(outputVectorPtr, ret);
++- outputVectorPtr += 4;
++-
++- inputVal = _mm_srli_si128(inputVal, 4);
++- interimVal = _mm_cvtepi8_epi32(inputVal);
++- ret = _mm_cvtepi32_ps(interimVal);
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_storeu_ps(outputVectorPtr, ret);
++- outputVectorPtr += 4;
++-
++- inputVal = _mm_srli_si128(inputVal, 4);
++- interimVal = _mm_cvtepi8_epi32(inputVal);
++- ret = _mm_cvtepi32_ps(interimVal);
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_storeu_ps(outputVectorPtr, ret);
++- outputVectorPtr += 4;
++-
++- inputVectorPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] = (float)(inputVector[number]) * iScalar;
++- }
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float* outputVectorPtr = outputVector;
+++ const float iScalar = 1.0 / scalar;
+++ __m128 invScalar = _mm_set_ps1(iScalar);
+++ const int8_t* inputVectorPtr = inputVector;
+++ __m128 ret;
+++ __m128i inputVal;
+++ __m128i interimVal;
+++
+++ for (; number < sixteenthPoints; number++) {
+++ inputVal = _mm_loadu_si128((__m128i*)inputVectorPtr);
+++
+++ interimVal = _mm_cvtepi8_epi32(inputVal);
+++ ret = _mm_cvtepi32_ps(interimVal);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_storeu_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 4;
+++
+++ inputVal = _mm_srli_si128(inputVal, 4);
+++ interimVal = _mm_cvtepi8_epi32(inputVal);
+++ ret = _mm_cvtepi32_ps(interimVal);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_storeu_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 4;
+++
+++ inputVal = _mm_srli_si128(inputVal, 4);
+++ interimVal = _mm_cvtepi8_epi32(inputVal);
+++ ret = _mm_cvtepi32_ps(interimVal);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_storeu_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 4;
+++
+++ inputVal = _mm_srli_si128(inputVal, 4);
+++ interimVal = _mm_cvtepi8_epi32(inputVal);
+++ ret = _mm_cvtepi32_ps(interimVal);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_storeu_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 4;
+++
+++ inputVectorPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (float)(inputVector[number]) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_8i_s32f_convert_32f_generic(float* outputVector, const int8_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_8i_s32f_convert_32f_generic(float* outputVector,
+++ const int8_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* outputVectorPtr = outputVector;
++- const int8_t* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++- const float iScalar = 1.0 / scalar;
++-
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((float)(*inputVectorPtr++)) * iScalar;
++- }
+++ float* outputVectorPtr = outputVector;
+++ const int8_t* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++ const float iScalar = 1.0 / scalar;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((float)(*inputVectorPtr++)) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++ #endif /* INCLUDED_VOLK_8s_CONVERT_32f_UNALIGNED8_H */
++
++ #ifndef INCLUDED_volk_8i_s32f_convert_32f_a_H
++@@ -190,195 +192,199 @@ volk_8i_s32f_convert_32f_generic(float* outputVector, const int8_t* inputVector,
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8i_s32f_convert_32f_a_avx2(float* outputVector, const int8_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_8i_s32f_convert_32f_a_avx2(float* outputVector,
+++ const int8_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float* outputVectorPtr = outputVector;
++- const float iScalar = 1.0 / scalar;
++- __m256 invScalar = _mm256_set1_ps( iScalar );
++- const int8_t* inputVectorPtr = inputVector;
++- __m256 ret;
++- __m128i inputVal128;
++- __m256i interimVal;
++-
++- for(;number < sixteenthPoints; number++){
++- inputVal128 = _mm_load_si128((__m128i*)inputVectorPtr);
++-
++- interimVal = _mm256_cvtepi8_epi32(inputVal128);
++- ret = _mm256_cvtepi32_ps(interimVal);
++- ret = _mm256_mul_ps(ret, invScalar);
++- _mm256_store_ps(outputVectorPtr, ret);
++- outputVectorPtr += 8;
++-
++- inputVal128 = _mm_srli_si128(inputVal128, 8);
++- interimVal = _mm256_cvtepi8_epi32(inputVal128);
++- ret = _mm256_cvtepi32_ps(interimVal);
++- ret = _mm256_mul_ps(ret, invScalar);
++- _mm256_store_ps(outputVectorPtr, ret);
++- outputVectorPtr += 8;
++-
++- inputVectorPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] = (float)(inputVector[number]) * iScalar;
++- }
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float* outputVectorPtr = outputVector;
+++ const float iScalar = 1.0 / scalar;
+++ __m256 invScalar = _mm256_set1_ps(iScalar);
+++ const int8_t* inputVectorPtr = inputVector;
+++ __m256 ret;
+++ __m128i inputVal128;
+++ __m256i interimVal;
+++
+++ for (; number < sixteenthPoints; number++) {
+++ inputVal128 = _mm_load_si128((__m128i*)inputVectorPtr);
+++
+++ interimVal = _mm256_cvtepi8_epi32(inputVal128);
+++ ret = _mm256_cvtepi32_ps(interimVal);
+++ ret = _mm256_mul_ps(ret, invScalar);
+++ _mm256_store_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 8;
+++
+++ inputVal128 = _mm_srli_si128(inputVal128, 8);
+++ interimVal = _mm256_cvtepi8_epi32(inputVal128);
+++ ret = _mm256_cvtepi32_ps(interimVal);
+++ ret = _mm256_mul_ps(ret, invScalar);
+++ _mm256_store_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 8;
+++
+++ inputVectorPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (float)(inputVector[number]) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void
++-volk_8i_s32f_convert_32f_a_sse4_1(float* outputVector, const int8_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_8i_s32f_convert_32f_a_sse4_1(float* outputVector,
+++ const int8_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++-
++- float* outputVectorPtr = outputVector;
++- const float iScalar = 1.0 / scalar;
++- __m128 invScalar = _mm_set_ps1(iScalar);
++- const int8_t* inputVectorPtr = inputVector;
++- __m128 ret;
++- __m128i inputVal;
++- __m128i interimVal;
++-
++- for(;number < sixteenthPoints; number++){
++- inputVal = _mm_load_si128((__m128i*)inputVectorPtr);
++-
++- interimVal = _mm_cvtepi8_epi32(inputVal);
++- ret = _mm_cvtepi32_ps(interimVal);
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_store_ps(outputVectorPtr, ret);
++- outputVectorPtr += 4;
++-
++- inputVal = _mm_srli_si128(inputVal, 4);
++- interimVal = _mm_cvtepi8_epi32(inputVal);
++- ret = _mm_cvtepi32_ps(interimVal);
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_store_ps(outputVectorPtr, ret);
++- outputVectorPtr += 4;
++-
++- inputVal = _mm_srli_si128(inputVal, 4);
++- interimVal = _mm_cvtepi8_epi32(inputVal);
++- ret = _mm_cvtepi32_ps(interimVal);
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_store_ps(outputVectorPtr, ret);
++- outputVectorPtr += 4;
++-
++- inputVal = _mm_srli_si128(inputVal, 4);
++- interimVal = _mm_cvtepi8_epi32(inputVal);
++- ret = _mm_cvtepi32_ps(interimVal);
++- ret = _mm_mul_ps(ret, invScalar);
++- _mm_store_ps(outputVectorPtr, ret);
++- outputVectorPtr += 4;
++-
++- inputVectorPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- outputVector[number] = (float)(inputVector[number]) * iScalar;
++- }
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++
+++ float* outputVectorPtr = outputVector;
+++ const float iScalar = 1.0 / scalar;
+++ __m128 invScalar = _mm_set_ps1(iScalar);
+++ const int8_t* inputVectorPtr = inputVector;
+++ __m128 ret;
+++ __m128i inputVal;
+++ __m128i interimVal;
+++
+++ for (; number < sixteenthPoints; number++) {
+++ inputVal = _mm_load_si128((__m128i*)inputVectorPtr);
+++
+++ interimVal = _mm_cvtepi8_epi32(inputVal);
+++ ret = _mm_cvtepi32_ps(interimVal);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_store_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 4;
+++
+++ inputVal = _mm_srli_si128(inputVal, 4);
+++ interimVal = _mm_cvtepi8_epi32(inputVal);
+++ ret = _mm_cvtepi32_ps(interimVal);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_store_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 4;
+++
+++ inputVal = _mm_srli_si128(inputVal, 4);
+++ interimVal = _mm_cvtepi8_epi32(inputVal);
+++ ret = _mm_cvtepi32_ps(interimVal);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_store_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 4;
+++
+++ inputVal = _mm_srli_si128(inputVal, 4);
+++ interimVal = _mm_cvtepi8_epi32(inputVal);
+++ ret = _mm_cvtepi32_ps(interimVal);
+++ ret = _mm_mul_ps(ret, invScalar);
+++ _mm_store_ps(outputVectorPtr, ret);
+++ outputVectorPtr += 4;
+++
+++ inputVectorPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ outputVector[number] = (float)(inputVector[number]) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_8i_s32f_convert_32f_neon(float* outputVector, const int8_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_8i_s32f_convert_32f_neon(float* outputVector,
+++ const int8_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* outputVectorPtr = outputVector;
++- const int8_t* inputVectorPtr = inputVector;
++-
++- const float iScalar = 1.0 / scalar;
++- const float32x4_t qiScalar = vdupq_n_f32(iScalar);
++-
++- int8x8x2_t inputVal;
++- float32x4x2_t outputFloat;
++- int16x8_t tmp;
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++- for(;number < sixteenthPoints; number++){
++- __VOLK_PREFETCH(inputVectorPtr+16);
++-
++- inputVal = vld2_s8(inputVectorPtr);
++- inputVal = vzip_s8(inputVal.val[0], inputVal.val[1]);
++- inputVectorPtr += 16;
++-
++- tmp = vmovl_s8(inputVal.val[0]);
++-
++- outputFloat.val[0] = vcvtq_f32_s32(vmovl_s16(vget_low_s16(tmp)));
++- outputFloat.val[0] = vmulq_f32(outputFloat.val[0], qiScalar);
++- vst1q_f32(outputVectorPtr, outputFloat.val[0]);
++- outputVectorPtr += 4;
++-
++- outputFloat.val[1] = vcvtq_f32_s32(vmovl_s16(vget_high_s16(tmp)));
++- outputFloat.val[1] = vmulq_f32(outputFloat.val[1], qiScalar);
++- vst1q_f32(outputVectorPtr, outputFloat.val[1]);
++- outputVectorPtr += 4;
++-
++- tmp = vmovl_s8(inputVal.val[1]);
++-
++- outputFloat.val[0] = vcvtq_f32_s32(vmovl_s16(vget_low_s16(tmp)));
++- outputFloat.val[0] = vmulq_f32(outputFloat.val[0], qiScalar);
++- vst1q_f32(outputVectorPtr, outputFloat.val[0]);
++- outputVectorPtr += 4;
++-
++- outputFloat.val[1] = vcvtq_f32_s32(vmovl_s16(vget_high_s16(tmp)));
++- outputFloat.val[1] = vmulq_f32(outputFloat.val[1], qiScalar);
++- vst1q_f32(outputVectorPtr, outputFloat.val[1]);
++- outputVectorPtr += 4;
++- }
++- for(number = sixteenthPoints * 16; number < num_points; number++){
++- *outputVectorPtr++ = ((float)(*inputVectorPtr++)) * iScalar;
++- }
+++ float* outputVectorPtr = outputVector;
+++ const int8_t* inputVectorPtr = inputVector;
+++
+++ const float iScalar = 1.0 / scalar;
+++ const float32x4_t qiScalar = vdupq_n_f32(iScalar);
+++
+++ int8x8x2_t inputVal;
+++ float32x4x2_t outputFloat;
+++ int16x8_t tmp;
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++ for (; number < sixteenthPoints; number++) {
+++ __VOLK_PREFETCH(inputVectorPtr + 16);
+++
+++ inputVal = vld2_s8(inputVectorPtr);
+++ inputVal = vzip_s8(inputVal.val[0], inputVal.val[1]);
+++ inputVectorPtr += 16;
+++
+++ tmp = vmovl_s8(inputVal.val[0]);
+++
+++ outputFloat.val[0] = vcvtq_f32_s32(vmovl_s16(vget_low_s16(tmp)));
+++ outputFloat.val[0] = vmulq_f32(outputFloat.val[0], qiScalar);
+++ vst1q_f32(outputVectorPtr, outputFloat.val[0]);
+++ outputVectorPtr += 4;
+++
+++ outputFloat.val[1] = vcvtq_f32_s32(vmovl_s16(vget_high_s16(tmp)));
+++ outputFloat.val[1] = vmulq_f32(outputFloat.val[1], qiScalar);
+++ vst1q_f32(outputVectorPtr, outputFloat.val[1]);
+++ outputVectorPtr += 4;
+++
+++ tmp = vmovl_s8(inputVal.val[1]);
+++
+++ outputFloat.val[0] = vcvtq_f32_s32(vmovl_s16(vget_low_s16(tmp)));
+++ outputFloat.val[0] = vmulq_f32(outputFloat.val[0], qiScalar);
+++ vst1q_f32(outputVectorPtr, outputFloat.val[0]);
+++ outputVectorPtr += 4;
+++
+++ outputFloat.val[1] = vcvtq_f32_s32(vmovl_s16(vget_high_s16(tmp)));
+++ outputFloat.val[1] = vmulq_f32(outputFloat.val[1], qiScalar);
+++ vst1q_f32(outputVectorPtr, outputFloat.val[1]);
+++ outputVectorPtr += 4;
+++ }
+++ for (number = sixteenthPoints * 16; number < num_points; number++) {
+++ *outputVectorPtr++ = ((float)(*inputVectorPtr++)) * iScalar;
+++ }
++ }
++
++ #endif /* LV_HAVE_NEON */
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_8i_s32f_convert_32f_a_generic(float* outputVector, const int8_t* inputVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_8i_s32f_convert_32f_a_generic(float* outputVector,
+++ const int8_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* outputVectorPtr = outputVector;
++- const int8_t* inputVectorPtr = inputVector;
++- unsigned int number = 0;
++- const float iScalar = 1.0 / scalar;
++-
++- for(number = 0; number < num_points; number++){
++- *outputVectorPtr++ = ((float)(*inputVectorPtr++)) * iScalar;
++- }
+++ float* outputVectorPtr = outputVector;
+++ const int8_t* inputVectorPtr = inputVector;
+++ unsigned int number = 0;
+++ const float iScalar = 1.0 / scalar;
+++
+++ for (number = 0; number < num_points; number++) {
+++ *outputVectorPtr++ = ((float)(*inputVectorPtr++)) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++ #ifdef LV_HAVE_ORC
++-extern void
++-volk_8i_s32f_convert_32f_a_orc_impl(float* outputVector, const int8_t* inputVector,
++- const float scalar, unsigned int num_points);
++-
++-static inline void
++-volk_8i_s32f_convert_32f_u_orc(float* outputVector, const int8_t* inputVector,
++- const float scalar, unsigned int num_points)
+++extern void volk_8i_s32f_convert_32f_a_orc_impl(float* outputVector,
+++ const int8_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points);
+++
+++static inline void volk_8i_s32f_convert_32f_u_orc(float* outputVector,
+++ const int8_t* inputVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float invscalar = 1.0 / scalar;
++- volk_8i_s32f_convert_32f_a_orc_impl(outputVector, inputVector, invscalar, num_points);
+++ float invscalar = 1.0 / scalar;
+++ volk_8i_s32f_convert_32f_a_orc_impl(outputVector, inputVector, invscalar, num_points);
++ }
++ #endif /* LV_HAVE_ORC */
++
++
++-
++ #endif /* INCLUDED_VOLK_8s_CONVERT_32f_ALIGNED8_H */
++-
++diff --git a/kernels/volk/volk_8ic_deinterleave_16i_x2.h b/kernels/volk/volk_8ic_deinterleave_16i_x2.h
++index b4cf251..fa998a0 100644
++--- a/kernels/volk/volk_8ic_deinterleave_16i_x2.h
+++++ b/kernels/volk/volk_8ic_deinterleave_16i_x2.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_8ic_deinterleave_16i_x2(int16_t* iBuffer, int16_t* qBuffer, const lv_8sc_t* complexVector, unsigned int num_points)
++- * \endcode
+++ * void volk_8ic_deinterleave_16i_x2(int16_t* iBuffer, int16_t* qBuffer, const lv_8sc_t*
+++ * complexVector, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -60,91 +60,150 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8ic_deinterleave_16i_x2_a_avx2(int16_t* iBuffer, int16_t* qBuffer,
++- const lv_8sc_t* complexVector, unsigned int num_points)
+++static inline void volk_8ic_deinterleave_16i_x2_a_avx2(int16_t* iBuffer,
+++ int16_t* qBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- int16_t* qBufferPtr = qBuffer;
++- __m256i MoveMask = _mm256_set_epi8(15, 13, 11, 9, 7, 5, 3, 1, 14, 12, 10, 8, 6, 4, 2, 0, 15, 13, 11, 9, 7, 5, 3, 1, 14, 12, 10, 8, 6, 4, 2, 0);
++- __m256i complexVal, iOutputVal, qOutputVal;
++- __m128i iOutputVal0, qOutputVal0;
++-
++- unsigned int sixteenthPoints = num_points / 16;
++-
++- for(number = 0; number < sixteenthPoints; number++){
++- complexVal = _mm256_load_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++-
++- complexVal = _mm256_shuffle_epi8(complexVal, MoveMask);
++- complexVal = _mm256_permute4x64_epi64(complexVal, 0xd8);
++-
++- iOutputVal0 = _mm256_extracti128_si256(complexVal, 0);
++- qOutputVal0 = _mm256_extracti128_si256(complexVal, 1);
++-
++- iOutputVal = _mm256_cvtepi8_epi16(iOutputVal0);
++- iOutputVal = _mm256_slli_epi16(iOutputVal, 8);
++-
++- qOutputVal = _mm256_cvtepi8_epi16(qOutputVal0);
++- qOutputVal = _mm256_slli_epi16(qOutputVal, 8);
++-
++- _mm256_store_si256((__m256i*)iBufferPtr, iOutputVal);
++- _mm256_store_si256((__m256i*)qBufferPtr, qOutputVal);
++-
++- iBufferPtr += 16;
++- qBufferPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((int16_t)*complexVectorPtr++) * 256; // load 8 bit Complexvector into 16 bit, shift left by 8 bits and store
++- *qBufferPtr++ = ((int16_t)*complexVectorPtr++) * 256;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ int16_t* qBufferPtr = qBuffer;
+++ __m256i MoveMask = _mm256_set_epi8(15,
+++ 13,
+++ 11,
+++ 9,
+++ 7,
+++ 5,
+++ 3,
+++ 1,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 15,
+++ 13,
+++ 11,
+++ 9,
+++ 7,
+++ 5,
+++ 3,
+++ 1,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0);
+++ __m256i complexVal, iOutputVal, qOutputVal;
+++ __m128i iOutputVal0, qOutputVal0;
+++
+++ unsigned int sixteenthPoints = num_points / 16;
+++
+++ for (number = 0; number < sixteenthPoints; number++) {
+++ complexVal = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ complexVal = _mm256_shuffle_epi8(complexVal, MoveMask);
+++ complexVal = _mm256_permute4x64_epi64(complexVal, 0xd8);
+++
+++ iOutputVal0 = _mm256_extracti128_si256(complexVal, 0);
+++ qOutputVal0 = _mm256_extracti128_si256(complexVal, 1);
+++
+++ iOutputVal = _mm256_cvtepi8_epi16(iOutputVal0);
+++ iOutputVal = _mm256_slli_epi16(iOutputVal, 8);
+++
+++ qOutputVal = _mm256_cvtepi8_epi16(qOutputVal0);
+++ qOutputVal = _mm256_slli_epi16(qOutputVal, 8);
+++
+++ _mm256_store_si256((__m256i*)iBufferPtr, iOutputVal);
+++ _mm256_store_si256((__m256i*)qBufferPtr, qOutputVal);
+++
+++ iBufferPtr += 16;
+++ qBufferPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ =
+++ ((int16_t)*complexVectorPtr++) *
+++ 256; // load 8 bit Complexvector into 16 bit, shift left by 8 bits and store
+++ *qBufferPtr++ = ((int16_t)*complexVectorPtr++) * 256;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void
++-volk_8ic_deinterleave_16i_x2_a_sse4_1(int16_t* iBuffer, int16_t* qBuffer,
++- const lv_8sc_t* complexVector, unsigned int num_points)
+++static inline void volk_8ic_deinterleave_16i_x2_a_sse4_1(int16_t* iBuffer,
+++ int16_t* qBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- int16_t* qBufferPtr = qBuffer;
++- __m128i iMoveMask = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0); // set 16 byte values
++- __m128i qMoveMask = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 15, 13, 11, 9, 7, 5, 3, 1);
++- __m128i complexVal, iOutputVal, qOutputVal;
++-
++- unsigned int eighthPoints = num_points / 8;
++-
++- for(number = 0; number < eighthPoints; number++){
++- complexVal = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 16; // aligned load
++-
++- iOutputVal = _mm_shuffle_epi8(complexVal, iMoveMask); // shuffle 16 bytes of 128bit complexVal
++- qOutputVal = _mm_shuffle_epi8(complexVal, qMoveMask);
++-
++- iOutputVal = _mm_cvtepi8_epi16(iOutputVal); // fills 2-byte sign extended versions of lower 8 bytes of input to output
++- iOutputVal = _mm_slli_epi16(iOutputVal, 8); // shift in left by 8 bits, each of the 8 16-bit integers, shift in with zeros
++-
++- qOutputVal = _mm_cvtepi8_epi16(qOutputVal);
++- qOutputVal = _mm_slli_epi16(qOutputVal, 8);
++-
++- _mm_store_si128((__m128i*)iBufferPtr, iOutputVal); // aligned store
++- _mm_store_si128((__m128i*)qBufferPtr, qOutputVal);
++-
++- iBufferPtr += 8;
++- qBufferPtr += 8;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((int16_t)*complexVectorPtr++) * 256; // load 8 bit Complexvector into 16 bit, shift left by 8 bits and store
++- *qBufferPtr++ = ((int16_t)*complexVectorPtr++) * 256;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ int16_t* qBufferPtr = qBuffer;
+++ __m128i iMoveMask = _mm_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0); // set 16 byte values
+++ __m128i qMoveMask = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 15, 13, 11, 9, 7, 5, 3, 1);
+++ __m128i complexVal, iOutputVal, qOutputVal;
+++
+++ unsigned int eighthPoints = num_points / 8;
+++
+++ for (number = 0; number < eighthPoints; number++) {
+++ complexVal = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 16; // aligned load
+++
+++ iOutputVal = _mm_shuffle_epi8(complexVal,
+++ iMoveMask); // shuffle 16 bytes of 128bit complexVal
+++ qOutputVal = _mm_shuffle_epi8(complexVal, qMoveMask);
+++
+++ iOutputVal = _mm_cvtepi8_epi16(iOutputVal); // fills 2-byte sign extended versions
+++ // of lower 8 bytes of input to output
+++ iOutputVal =
+++ _mm_slli_epi16(iOutputVal, 8); // shift in left by 8 bits, each of the 8
+++ // 16-bit integers, shift in with zeros
+++
+++ qOutputVal = _mm_cvtepi8_epi16(qOutputVal);
+++ qOutputVal = _mm_slli_epi16(qOutputVal, 8);
+++
+++ _mm_store_si128((__m128i*)iBufferPtr, iOutputVal); // aligned store
+++ _mm_store_si128((__m128i*)qBufferPtr, qOutputVal);
+++
+++ iBufferPtr += 8;
+++ qBufferPtr += 8;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ =
+++ ((int16_t)*complexVectorPtr++) *
+++ 256; // load 8 bit Complexvector into 16 bit, shift left by 8 bits and store
+++ *qBufferPtr++ = ((int16_t)*complexVectorPtr++) * 256;
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++@@ -152,86 +211,111 @@ volk_8ic_deinterleave_16i_x2_a_sse4_1(int16_t* iBuffer, int16_t* qBuffer,
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_8ic_deinterleave_16i_x2_a_avx(int16_t* iBuffer, int16_t* qBuffer,
++- const lv_8sc_t* complexVector, unsigned int num_points)
+++static inline void volk_8ic_deinterleave_16i_x2_a_avx(int16_t* iBuffer,
+++ int16_t* qBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- int16_t* qBufferPtr = qBuffer;
++- __m128i iMoveMask = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0); // set 16 byte values
++- __m128i qMoveMask = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 15, 13, 11, 9, 7, 5, 3, 1);
++- __m256i complexVal, iOutputVal, qOutputVal;
++- __m128i complexVal1, complexVal0;
++- __m128i iOutputVal1, iOutputVal0, qOutputVal1, qOutputVal0;
++-
++- unsigned int sixteenthPoints = num_points / 16;
++-
++- for(number = 0; number < sixteenthPoints; number++){
++- complexVal = _mm256_load_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32; // aligned load
++-
++- // Extract from complexVal to iOutputVal and qOutputVal
++- complexVal1 = _mm256_extractf128_si256(complexVal, 1);
++- complexVal0 = _mm256_extractf128_si256(complexVal, 0);
++-
++- iOutputVal1 = _mm_shuffle_epi8(complexVal1, iMoveMask); // shuffle 16 bytes of 128bit complexVal
++- iOutputVal0 = _mm_shuffle_epi8(complexVal0, iMoveMask);
++- qOutputVal1 = _mm_shuffle_epi8(complexVal1, qMoveMask);
++- qOutputVal0 = _mm_shuffle_epi8(complexVal0, qMoveMask);
++-
++- iOutputVal1 = _mm_cvtepi8_epi16(iOutputVal1); // fills 2-byte sign extended versions of lower 8 bytes of input to output
++- iOutputVal1 = _mm_slli_epi16(iOutputVal1, 8); // shift in left by 8 bits, each of the 8 16-bit integers, shift in with zeros
++- iOutputVal0 = _mm_cvtepi8_epi16(iOutputVal0);
++- iOutputVal0 = _mm_slli_epi16(iOutputVal0, 8);
++-
++- qOutputVal1 = _mm_cvtepi8_epi16(qOutputVal1);
++- qOutputVal1 = _mm_slli_epi16(qOutputVal1, 8);
++- qOutputVal0 = _mm_cvtepi8_epi16(qOutputVal0);
++- qOutputVal0 = _mm_slli_epi16(qOutputVal0, 8);
++-
++- // Pack iOutputVal0,1 to iOutputVal
++- __m256i dummy = _mm256_setzero_si256();
++- iOutputVal = _mm256_insertf128_si256(dummy, iOutputVal0, 0);
++- iOutputVal = _mm256_insertf128_si256(iOutputVal, iOutputVal1, 1);
++- qOutputVal = _mm256_insertf128_si256(dummy, qOutputVal0, 0);
++- qOutputVal = _mm256_insertf128_si256(qOutputVal, qOutputVal1, 1);
++-
++- _mm256_store_si256((__m256i*)iBufferPtr, iOutputVal); // aligned store
++- _mm256_store_si256((__m256i*)qBufferPtr, qOutputVal);
++-
++- iBufferPtr += 16;
++- qBufferPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((int16_t)*complexVectorPtr++) * 256; // load 8 bit Complexvector into 16 bit, shift left by 8 bits and store
++- *qBufferPtr++ = ((int16_t)*complexVectorPtr++) * 256;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ int16_t* qBufferPtr = qBuffer;
+++ __m128i iMoveMask = _mm_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0); // set 16 byte values
+++ __m128i qMoveMask = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 15, 13, 11, 9, 7, 5, 3, 1);
+++ __m256i complexVal, iOutputVal, qOutputVal;
+++ __m128i complexVal1, complexVal0;
+++ __m128i iOutputVal1, iOutputVal0, qOutputVal1, qOutputVal0;
+++
+++ unsigned int sixteenthPoints = num_points / 16;
+++
+++ for (number = 0; number < sixteenthPoints; number++) {
+++ complexVal = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32; // aligned load
+++
+++ // Extract from complexVal to iOutputVal and qOutputVal
+++ complexVal1 = _mm256_extractf128_si256(complexVal, 1);
+++ complexVal0 = _mm256_extractf128_si256(complexVal, 0);
+++
+++ iOutputVal1 = _mm_shuffle_epi8(
+++ complexVal1, iMoveMask); // shuffle 16 bytes of 128bit complexVal
+++ iOutputVal0 = _mm_shuffle_epi8(complexVal0, iMoveMask);
+++ qOutputVal1 = _mm_shuffle_epi8(complexVal1, qMoveMask);
+++ qOutputVal0 = _mm_shuffle_epi8(complexVal0, qMoveMask);
+++
+++ iOutputVal1 =
+++ _mm_cvtepi8_epi16(iOutputVal1); // fills 2-byte sign extended versions of
+++ // lower 8 bytes of input to output
+++ iOutputVal1 =
+++ _mm_slli_epi16(iOutputVal1, 8); // shift in left by 8 bits, each of the 8
+++ // 16-bit integers, shift in with zeros
+++ iOutputVal0 = _mm_cvtepi8_epi16(iOutputVal0);
+++ iOutputVal0 = _mm_slli_epi16(iOutputVal0, 8);
+++
+++ qOutputVal1 = _mm_cvtepi8_epi16(qOutputVal1);
+++ qOutputVal1 = _mm_slli_epi16(qOutputVal1, 8);
+++ qOutputVal0 = _mm_cvtepi8_epi16(qOutputVal0);
+++ qOutputVal0 = _mm_slli_epi16(qOutputVal0, 8);
+++
+++ // Pack iOutputVal0,1 to iOutputVal
+++ __m256i dummy = _mm256_setzero_si256();
+++ iOutputVal = _mm256_insertf128_si256(dummy, iOutputVal0, 0);
+++ iOutputVal = _mm256_insertf128_si256(iOutputVal, iOutputVal1, 1);
+++ qOutputVal = _mm256_insertf128_si256(dummy, qOutputVal0, 0);
+++ qOutputVal = _mm256_insertf128_si256(qOutputVal, qOutputVal1, 1);
+++
+++ _mm256_store_si256((__m256i*)iBufferPtr, iOutputVal); // aligned store
+++ _mm256_store_si256((__m256i*)qBufferPtr, qOutputVal);
+++
+++ iBufferPtr += 16;
+++ qBufferPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ =
+++ ((int16_t)*complexVectorPtr++) *
+++ 256; // load 8 bit Complexvector into 16 bit, shift left by 8 bits and store
+++ *qBufferPtr++ = ((int16_t)*complexVectorPtr++) * 256;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_8ic_deinterleave_16i_x2_generic(int16_t* iBuffer, int16_t* qBuffer,
++- const lv_8sc_t* complexVector, unsigned int num_points)
+++static inline void volk_8ic_deinterleave_16i_x2_generic(int16_t* iBuffer,
+++ int16_t* qBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- const int8_t* complexVectorPtr = (const int8_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- int16_t* qBufferPtr = qBuffer;
++- unsigned int number;
++- for(number = 0; number < num_points; number++){
++- *iBufferPtr++ = (int16_t)(*complexVectorPtr++)*256;
++- *qBufferPtr++ = (int16_t)(*complexVectorPtr++)*256;
++- }
+++ const int8_t* complexVectorPtr = (const int8_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ int16_t* qBufferPtr = qBuffer;
+++ unsigned int number;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = (int16_t)(*complexVectorPtr++) * 256;
+++ *qBufferPtr++ = (int16_t)(*complexVectorPtr++) * 256;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++ #endif /* INCLUDED_volk_8ic_deinterleave_16i_x2_a_H */
++
++ #ifndef INCLUDED_volk_8ic_deinterleave_16i_x2_u_H
++@@ -243,47 +327,82 @@ volk_8ic_deinterleave_16i_x2_generic(int16_t* iBuffer, int16_t* qBuffer,
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8ic_deinterleave_16i_x2_u_avx2(int16_t* iBuffer, int16_t* qBuffer,
++- const lv_8sc_t* complexVector, unsigned int num_points)
+++static inline void volk_8ic_deinterleave_16i_x2_u_avx2(int16_t* iBuffer,
+++ int16_t* qBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- int16_t* qBufferPtr = qBuffer;
++- __m256i MoveMask = _mm256_set_epi8(15, 13, 11, 9, 7, 5, 3, 1, 14, 12, 10, 8, 6, 4, 2, 0, 15, 13, 11, 9, 7, 5, 3, 1, 14, 12, 10, 8, 6, 4, 2, 0);
++- __m256i complexVal, iOutputVal, qOutputVal;
++- __m128i iOutputVal0, qOutputVal0;
++-
++- unsigned int sixteenthPoints = num_points / 16;
++-
++- for(number = 0; number < sixteenthPoints; number++){
++- complexVal = _mm256_loadu_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++-
++- complexVal = _mm256_shuffle_epi8(complexVal, MoveMask);
++- complexVal = _mm256_permute4x64_epi64(complexVal, 0xd8);
++-
++- iOutputVal0 = _mm256_extracti128_si256(complexVal, 0);
++- qOutputVal0 = _mm256_extracti128_si256(complexVal, 1);
++-
++- iOutputVal = _mm256_cvtepi8_epi16(iOutputVal0);
++- iOutputVal = _mm256_slli_epi16(iOutputVal, 8);
++-
++- qOutputVal = _mm256_cvtepi8_epi16(qOutputVal0);
++- qOutputVal = _mm256_slli_epi16(qOutputVal, 8);
++-
++- _mm256_storeu_si256((__m256i*)iBufferPtr, iOutputVal);
++- _mm256_storeu_si256((__m256i*)qBufferPtr, qOutputVal);
++-
++- iBufferPtr += 16;
++- qBufferPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((int16_t)*complexVectorPtr++) * 256; // load 8 bit Complexvector into 16 bit, shift left by 8 bits and store
++- *qBufferPtr++ = ((int16_t)*complexVectorPtr++) * 256;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ int16_t* qBufferPtr = qBuffer;
+++ __m256i MoveMask = _mm256_set_epi8(15,
+++ 13,
+++ 11,
+++ 9,
+++ 7,
+++ 5,
+++ 3,
+++ 1,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 15,
+++ 13,
+++ 11,
+++ 9,
+++ 7,
+++ 5,
+++ 3,
+++ 1,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0);
+++ __m256i complexVal, iOutputVal, qOutputVal;
+++ __m128i iOutputVal0, qOutputVal0;
+++
+++ unsigned int sixteenthPoints = num_points / 16;
+++
+++ for (number = 0; number < sixteenthPoints; number++) {
+++ complexVal = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ complexVal = _mm256_shuffle_epi8(complexVal, MoveMask);
+++ complexVal = _mm256_permute4x64_epi64(complexVal, 0xd8);
+++
+++ iOutputVal0 = _mm256_extracti128_si256(complexVal, 0);
+++ qOutputVal0 = _mm256_extracti128_si256(complexVal, 1);
+++
+++ iOutputVal = _mm256_cvtepi8_epi16(iOutputVal0);
+++ iOutputVal = _mm256_slli_epi16(iOutputVal, 8);
+++
+++ qOutputVal = _mm256_cvtepi8_epi16(qOutputVal0);
+++ qOutputVal = _mm256_slli_epi16(qOutputVal, 8);
+++
+++ _mm256_storeu_si256((__m256i*)iBufferPtr, iOutputVal);
+++ _mm256_storeu_si256((__m256i*)qBufferPtr, qOutputVal);
+++
+++ iBufferPtr += 16;
+++ qBufferPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ =
+++ ((int16_t)*complexVectorPtr++) *
+++ 256; // load 8 bit Complexvector into 16 bit, shift left by 8 bits and store
+++ *qBufferPtr++ = ((int16_t)*complexVectorPtr++) * 256;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++ #endif /* INCLUDED_volk_8ic_deinterleave_16i_x2_u_H */
++diff --git a/kernels/volk/volk_8ic_deinterleave_real_16i.h b/kernels/volk/volk_8ic_deinterleave_real_16i.h
++index f15879a..aaebb47 100644
++--- a/kernels/volk/volk_8ic_deinterleave_real_16i.h
+++++ b/kernels/volk/volk_8ic_deinterleave_real_16i.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_8ic_deinterleave_real_16i(int16_t* iBuffer, const lv_8sc_t* complexVector, unsigned int num_points)
++- * \endcode
+++ * void volk_8ic_deinterleave_real_16i(int16_t* iBuffer, const lv_8sc_t* complexVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -60,75 +60,109 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8ic_deinterleave_real_16i_a_avx2(int16_t* iBuffer, const lv_8sc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_8ic_deinterleave_real_16i_a_avx2(int16_t* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- __m256i moveMask = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
++- __m256i complexVal, outputVal;
++- __m128i outputVal0;
++-
++- unsigned int sixteenthPoints = num_points / 16;
++-
++- for(number = 0; number < sixteenthPoints; number++){
++- complexVal = _mm256_load_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++-
++- complexVal = _mm256_shuffle_epi8(complexVal, moveMask);
++- complexVal = _mm256_permute4x64_epi64(complexVal, 0xd8);
++-
++- outputVal0 = _mm256_extractf128_si256(complexVal, 0);
++-
++- outputVal = _mm256_cvtepi8_epi16(outputVal0);
++- outputVal = _mm256_slli_epi16(outputVal, 7);
++-
++- _mm256_store_si256((__m256i*)iBufferPtr, outputVal);
++-
++- iBufferPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((int16_t)*complexVectorPtr++) * 128;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ __m256i moveMask = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0);
+++ __m256i complexVal, outputVal;
+++ __m128i outputVal0;
+++
+++ unsigned int sixteenthPoints = num_points / 16;
+++
+++ for (number = 0; number < sixteenthPoints; number++) {
+++ complexVal = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ complexVal = _mm256_shuffle_epi8(complexVal, moveMask);
+++ complexVal = _mm256_permute4x64_epi64(complexVal, 0xd8);
+++
+++ outputVal0 = _mm256_extractf128_si256(complexVal, 0);
+++
+++ outputVal = _mm256_cvtepi8_epi16(outputVal0);
+++ outputVal = _mm256_slli_epi16(outputVal, 7);
+++
+++ _mm256_store_si256((__m256i*)iBufferPtr, outputVal);
+++
+++ iBufferPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = ((int16_t)*complexVectorPtr++) * 128;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++-static inline void
++-volk_8ic_deinterleave_real_16i_a_sse4_1(int16_t* iBuffer, const lv_8sc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_8ic_deinterleave_real_16i_a_sse4_1(int16_t* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- __m128i moveMask = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
++- __m128i complexVal, outputVal;
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ __m128i moveMask = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
+++ __m128i complexVal, outputVal;
++
++- unsigned int eighthPoints = num_points / 8;
+++ unsigned int eighthPoints = num_points / 8;
++
++- for(number = 0; number < eighthPoints; number++){
++- complexVal = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 16;
+++ for (number = 0; number < eighthPoints; number++) {
+++ complexVal = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 16;
++
++- complexVal = _mm_shuffle_epi8(complexVal, moveMask);
+++ complexVal = _mm_shuffle_epi8(complexVal, moveMask);
++
++- outputVal = _mm_cvtepi8_epi16(complexVal);
++- outputVal = _mm_slli_epi16(outputVal, 7);
+++ outputVal = _mm_cvtepi8_epi16(complexVal);
+++ outputVal = _mm_slli_epi16(outputVal, 7);
++
++- _mm_store_si128((__m128i*)iBufferPtr, outputVal);
++- iBufferPtr += 8;
++- }
+++ _mm_store_si128((__m128i*)iBufferPtr, outputVal);
+++ iBufferPtr += 8;
+++ }
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((int16_t)*complexVectorPtr++) * 128;
++- complexVectorPtr++;
++- }
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = ((int16_t)*complexVectorPtr++) * 128;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++@@ -136,63 +170,65 @@ volk_8ic_deinterleave_real_16i_a_sse4_1(int16_t* iBuffer, const lv_8sc_t* comple
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_8ic_deinterleave_real_16i_a_avx(int16_t* iBuffer, const lv_8sc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_8ic_deinterleave_real_16i_a_avx(int16_t* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- __m128i moveMask = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
++- __m256i complexVal, outputVal;
++- __m128i complexVal1, complexVal0, outputVal1, outputVal0;
++-
++- unsigned int sixteenthPoints = num_points / 16;
++-
++- for(number = 0; number < sixteenthPoints; number++){
++- complexVal = _mm256_load_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++-
++- complexVal1 = _mm256_extractf128_si256(complexVal, 1);
++- complexVal0 = _mm256_extractf128_si256(complexVal, 0);
++-
++- outputVal1 = _mm_shuffle_epi8(complexVal1, moveMask);
++- outputVal0 = _mm_shuffle_epi8(complexVal0, moveMask);
++-
++- outputVal1 = _mm_cvtepi8_epi16(outputVal1);
++- outputVal1 = _mm_slli_epi16(outputVal1, 7);
++- outputVal0 = _mm_cvtepi8_epi16(outputVal0);
++- outputVal0 = _mm_slli_epi16(outputVal0, 7);
++-
++- __m256i dummy = _mm256_setzero_si256();
++- outputVal = _mm256_insertf128_si256(dummy, outputVal0, 0);
++- outputVal = _mm256_insertf128_si256(outputVal, outputVal1, 1);
++- _mm256_store_si256((__m256i*)iBufferPtr, outputVal);
++-
++- iBufferPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((int16_t)*complexVectorPtr++) * 128;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ __m128i moveMask = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
+++ __m256i complexVal, outputVal;
+++ __m128i complexVal1, complexVal0, outputVal1, outputVal0;
+++
+++ unsigned int sixteenthPoints = num_points / 16;
+++
+++ for (number = 0; number < sixteenthPoints; number++) {
+++ complexVal = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ complexVal1 = _mm256_extractf128_si256(complexVal, 1);
+++ complexVal0 = _mm256_extractf128_si256(complexVal, 0);
+++
+++ outputVal1 = _mm_shuffle_epi8(complexVal1, moveMask);
+++ outputVal0 = _mm_shuffle_epi8(complexVal0, moveMask);
+++
+++ outputVal1 = _mm_cvtepi8_epi16(outputVal1);
+++ outputVal1 = _mm_slli_epi16(outputVal1, 7);
+++ outputVal0 = _mm_cvtepi8_epi16(outputVal0);
+++ outputVal0 = _mm_slli_epi16(outputVal0, 7);
+++
+++ __m256i dummy = _mm256_setzero_si256();
+++ outputVal = _mm256_insertf128_si256(dummy, outputVal0, 0);
+++ outputVal = _mm256_insertf128_si256(outputVal, outputVal1, 1);
+++ _mm256_store_si256((__m256i*)iBufferPtr, outputVal);
+++
+++ iBufferPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = ((int16_t)*complexVectorPtr++) * 128;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_8ic_deinterleave_real_16i_generic(int16_t* iBuffer, const lv_8sc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_8ic_deinterleave_real_16i_generic(int16_t* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (const int8_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- for(number = 0; number < num_points; number++){
++- *iBufferPtr++ = ((int16_t)(*complexVectorPtr++)) * 128;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (const int8_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = ((int16_t)(*complexVectorPtr++)) * 128;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -209,40 +245,72 @@ volk_8ic_deinterleave_real_16i_generic(int16_t* iBuffer, const lv_8sc_t* complex
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8ic_deinterleave_real_16i_u_avx2(int16_t* iBuffer, const lv_8sc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_8ic_deinterleave_real_16i_u_avx2(int16_t* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int16_t* iBufferPtr = iBuffer;
++- __m256i moveMask = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
++- __m256i complexVal, outputVal;
++- __m128i outputVal0;
++-
++- unsigned int sixteenthPoints = num_points / 16;
++-
++- for(number = 0; number < sixteenthPoints; number++){
++- complexVal = _mm256_loadu_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++-
++- complexVal = _mm256_shuffle_epi8(complexVal, moveMask);
++- complexVal = _mm256_permute4x64_epi64(complexVal, 0xd8);
++-
++- outputVal0 = _mm256_extractf128_si256(complexVal, 0);
++-
++- outputVal = _mm256_cvtepi8_epi16(outputVal0);
++- outputVal = _mm256_slli_epi16(outputVal, 7);
++-
++- _mm256_storeu_si256((__m256i*)iBufferPtr, outputVal);
++-
++- iBufferPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = ((int16_t)*complexVectorPtr++) * 128;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int16_t* iBufferPtr = iBuffer;
+++ __m256i moveMask = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0);
+++ __m256i complexVal, outputVal;
+++ __m128i outputVal0;
+++
+++ unsigned int sixteenthPoints = num_points / 16;
+++
+++ for (number = 0; number < sixteenthPoints; number++) {
+++ complexVal = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ complexVal = _mm256_shuffle_epi8(complexVal, moveMask);
+++ complexVal = _mm256_permute4x64_epi64(complexVal, 0xd8);
+++
+++ outputVal0 = _mm256_extractf128_si256(complexVal, 0);
+++
+++ outputVal = _mm256_cvtepi8_epi16(outputVal0);
+++ outputVal = _mm256_slli_epi16(outputVal, 7);
+++
+++ _mm256_storeu_si256((__m256i*)iBufferPtr, outputVal);
+++
+++ iBufferPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = ((int16_t)*complexVectorPtr++) * 128;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++ #endif /* INCLUDED_volk_8ic_deinterleave_real_16i_u_H */
++diff --git a/kernels/volk/volk_8ic_deinterleave_real_8i.h b/kernels/volk/volk_8ic_deinterleave_real_8i.h
++index 6cc3f15..a1a835d 100644
++--- a/kernels/volk/volk_8ic_deinterleave_real_8i.h
+++++ b/kernels/volk/volk_8ic_deinterleave_real_8i.h
++@@ -30,8 +30,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_8ic_deinterleave_real_8i(int8_t* iBuffer, const lv_8sc_t* complexVector, unsigned int num_points)
++- * \endcode
+++ * void volk_8ic_deinterleave_real_8i(int8_t* iBuffer, const lv_8sc_t* complexVector,
+++ * unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -59,40 +59,102 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8ic_deinterleave_real_8i_a_avx2(int8_t* iBuffer, const lv_8sc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_8ic_deinterleave_real_8i_a_avx2(int8_t* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int8_t* iBufferPtr = iBuffer;
++- __m256i moveMask1 = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
++- __m256i moveMask2 = _mm256_set_epi8(14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
++- __m256i complexVal1, complexVal2, outputVal;
++-
++- unsigned int thirtysecondPoints = num_points / 32;
++-
++- for(number = 0; number < thirtysecondPoints; number++){
++-
++- complexVal1 = _mm256_load_si256((__m256i*)complexVectorPtr);
++- complexVectorPtr += 32;
++- complexVal2 = _mm256_load_si256((__m256i*)complexVectorPtr);
++- complexVectorPtr += 32;
++-
++- complexVal1 = _mm256_shuffle_epi8(complexVal1, moveMask1);
++- complexVal2 = _mm256_shuffle_epi8(complexVal2, moveMask2);
++- outputVal = _mm256_or_si256(complexVal1, complexVal2);
++- outputVal = _mm256_permute4x64_epi64(outputVal, 0xd8);
++-
++- _mm256_store_si256((__m256i*)iBufferPtr, outputVal);
++- iBufferPtr += 32;
++- }
++-
++- number = thirtysecondPoints * 32;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int8_t* iBufferPtr = iBuffer;
+++ __m256i moveMask1 = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0);
+++ __m256i moveMask2 = _mm256_set_epi8(14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80);
+++ __m256i complexVal1, complexVal2, outputVal;
+++
+++ unsigned int thirtysecondPoints = num_points / 32;
+++
+++ for (number = 0; number < thirtysecondPoints; number++) {
+++
+++ complexVal1 = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal2 = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ complexVal1 = _mm256_shuffle_epi8(complexVal1, moveMask1);
+++ complexVal2 = _mm256_shuffle_epi8(complexVal2, moveMask2);
+++ outputVal = _mm256_or_si256(complexVal1, complexVal2);
+++ outputVal = _mm256_permute4x64_epi64(outputVal, 0xd8);
+++
+++ _mm256_store_si256((__m256i*)iBufferPtr, outputVal);
+++ iBufferPtr += 32;
+++ }
+++
+++ number = thirtysecondPoints * 32;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -100,37 +162,41 @@ volk_8ic_deinterleave_real_8i_a_avx2(int8_t* iBuffer, const lv_8sc_t* complexVec
++ #ifdef LV_HAVE_SSSE3
++ #include <tmmintrin.h>
++
++-static inline void
++-volk_8ic_deinterleave_real_8i_a_ssse3(int8_t* iBuffer, const lv_8sc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_8ic_deinterleave_real_8i_a_ssse3(int8_t* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int8_t* iBufferPtr = iBuffer;
++- __m128i moveMask1 = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
++- __m128i moveMask2 = _mm_set_epi8(14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
++- __m128i complexVal1, complexVal2, outputVal;
++-
++- unsigned int sixteenthPoints = num_points / 16;
++-
++- for(number = 0; number < sixteenthPoints; number++){
++- complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 16;
++- complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 16;
++-
++- complexVal1 = _mm_shuffle_epi8(complexVal1, moveMask1);
++- complexVal2 = _mm_shuffle_epi8(complexVal2, moveMask2);
++-
++- outputVal = _mm_or_si128(complexVal1, complexVal2);
++-
++- _mm_store_si128((__m128i*)iBufferPtr, outputVal);
++- iBufferPtr += 16;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int8_t* iBufferPtr = iBuffer;
+++ __m128i moveMask1 = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
+++ __m128i moveMask2 = _mm_set_epi8(
+++ 14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+++ __m128i complexVal1, complexVal2, outputVal;
+++
+++ unsigned int sixteenthPoints = num_points / 16;
+++
+++ for (number = 0; number < sixteenthPoints; number++) {
+++ complexVal1 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++ complexVal2 = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++
+++ complexVal1 = _mm_shuffle_epi8(complexVal1, moveMask1);
+++ complexVal2 = _mm_shuffle_epi8(complexVal2, moveMask2);
+++
+++ outputVal = _mm_or_si128(complexVal1, complexVal2);
+++
+++ _mm_store_si128((__m128i*)iBufferPtr, outputVal);
+++ iBufferPtr += 16;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSSE3 */
++
++@@ -138,72 +204,75 @@ volk_8ic_deinterleave_real_8i_a_ssse3(int8_t* iBuffer, const lv_8sc_t* complexVe
++ #ifdef LV_HAVE_AVX
++ #include <immintrin.h>
++
++-static inline void
++-volk_8ic_deinterleave_real_8i_a_avx(int8_t* iBuffer, const lv_8sc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_8ic_deinterleave_real_8i_a_avx(int8_t* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int8_t* iBufferPtr = iBuffer;
++- __m128i moveMaskL = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
++- __m128i moveMaskH = _mm_set_epi8(14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
++- __m256i complexVal1, complexVal2, outputVal;
++- __m128i complexVal1H, complexVal1L, complexVal2H, complexVal2L, outputVal1, outputVal2;
++-
++- unsigned int thirtysecondPoints = num_points / 32;
++-
++- for(number = 0; number < thirtysecondPoints; number++){
++-
++- complexVal1 = _mm256_load_si256((__m256i*)complexVectorPtr);
++- complexVectorPtr += 32;
++- complexVal2 = _mm256_load_si256((__m256i*)complexVectorPtr);
++- complexVectorPtr += 32;
++-
++- complexVal1H = _mm256_extractf128_si256(complexVal1, 1);
++- complexVal1L = _mm256_extractf128_si256(complexVal1, 0);
++- complexVal2H = _mm256_extractf128_si256(complexVal2, 1);
++- complexVal2L = _mm256_extractf128_si256(complexVal2, 0);
++-
++- complexVal1H = _mm_shuffle_epi8(complexVal1H, moveMaskH);
++- complexVal1L = _mm_shuffle_epi8(complexVal1L, moveMaskL);
++- outputVal1 = _mm_or_si128(complexVal1H, complexVal1L);
++-
++-
++- complexVal2H = _mm_shuffle_epi8(complexVal2H, moveMaskH);
++- complexVal2L = _mm_shuffle_epi8(complexVal2L, moveMaskL);
++- outputVal2 = _mm_or_si128(complexVal2H, complexVal2L);
++-
++- __m256i dummy = _mm256_setzero_si256();
++- outputVal = _mm256_insertf128_si256(dummy, outputVal1, 0);
++- outputVal = _mm256_insertf128_si256(outputVal, outputVal2, 1);
++-
++-
++- _mm256_store_si256((__m256i*)iBufferPtr, outputVal);
++- iBufferPtr += 32;
++- }
++-
++- number = thirtysecondPoints * 32;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int8_t* iBufferPtr = iBuffer;
+++ __m128i moveMaskL = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
+++ __m128i moveMaskH = _mm_set_epi8(
+++ 14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+++ __m256i complexVal1, complexVal2, outputVal;
+++ __m128i complexVal1H, complexVal1L, complexVal2H, complexVal2L, outputVal1,
+++ outputVal2;
+++
+++ unsigned int thirtysecondPoints = num_points / 32;
+++
+++ for (number = 0; number < thirtysecondPoints; number++) {
+++
+++ complexVal1 = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal2 = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ complexVal1H = _mm256_extractf128_si256(complexVal1, 1);
+++ complexVal1L = _mm256_extractf128_si256(complexVal1, 0);
+++ complexVal2H = _mm256_extractf128_si256(complexVal2, 1);
+++ complexVal2L = _mm256_extractf128_si256(complexVal2, 0);
+++
+++ complexVal1H = _mm_shuffle_epi8(complexVal1H, moveMaskH);
+++ complexVal1L = _mm_shuffle_epi8(complexVal1L, moveMaskL);
+++ outputVal1 = _mm_or_si128(complexVal1H, complexVal1L);
+++
+++
+++ complexVal2H = _mm_shuffle_epi8(complexVal2H, moveMaskH);
+++ complexVal2L = _mm_shuffle_epi8(complexVal2L, moveMaskL);
+++ outputVal2 = _mm_or_si128(complexVal2H, complexVal2L);
+++
+++ __m256i dummy = _mm256_setzero_si256();
+++ outputVal = _mm256_insertf128_si256(dummy, outputVal1, 0);
+++ outputVal = _mm256_insertf128_si256(outputVal, outputVal2, 1);
+++
+++
+++ _mm256_store_si256((__m256i*)iBufferPtr, outputVal);
+++ iBufferPtr += 32;
+++ }
+++
+++ number = thirtysecondPoints * 32;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX */
++
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_8ic_deinterleave_real_8i_generic(int8_t* iBuffer, const lv_8sc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_8ic_deinterleave_real_8i_generic(int8_t* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int8_t* iBufferPtr = iBuffer;
++- for(number = 0; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int8_t* iBufferPtr = iBuffer;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -211,26 +280,27 @@ volk_8ic_deinterleave_real_8i_generic(int8_t* iBuffer, const lv_8sc_t* complexVe
++ #ifdef LV_HAVE_NEON
++ #include <arm_neon.h>
++
++-static inline void
++-volk_8ic_deinterleave_real_8i_neon(int8_t* iBuffer, const lv_8sc_t* complexVector, unsigned int num_points)
+++static inline void volk_8ic_deinterleave_real_8i_neon(int8_t* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number;
++- unsigned int sixteenth_points = num_points / 16;
++-
++- int8x16x2_t input_vector;
++- for(number=0; number < sixteenth_points; ++number) {
++- input_vector = vld2q_s8((int8_t*) complexVector );
++- vst1q_s8(iBuffer, input_vector.val[0]);
++- iBuffer += 16;
++- complexVector += 16;
++- }
++-
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int8_t* iBufferPtr = iBuffer;
++- for(number = sixteenth_points*16; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ unsigned int number;
+++ unsigned int sixteenth_points = num_points / 16;
+++
+++ int8x16x2_t input_vector;
+++ for (number = 0; number < sixteenth_points; ++number) {
+++ input_vector = vld2q_s8((int8_t*)complexVector);
+++ vst1q_s8(iBuffer, input_vector.val[0]);
+++ iBuffer += 16;
+++ complexVector += 16;
+++ }
+++
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int8_t* iBufferPtr = iBuffer;
+++ for (number = sixteenth_points * 16; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_NEON */
++
++@@ -246,40 +316,102 @@ volk_8ic_deinterleave_real_8i_neon(int8_t* iBuffer, const lv_8sc_t* complexVecto
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8ic_deinterleave_real_8i_u_avx2(int8_t* iBuffer, const lv_8sc_t* complexVector,
++- unsigned int num_points)
+++static inline void volk_8ic_deinterleave_real_8i_u_avx2(int8_t* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (int8_t*)complexVector;
++- int8_t* iBufferPtr = iBuffer;
++- __m256i moveMask1 = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
++- __m256i moveMask2 = _mm256_set_epi8(14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
++- __m256i complexVal1, complexVal2, outputVal;
++-
++- unsigned int thirtysecondPoints = num_points / 32;
++-
++- for(number = 0; number < thirtysecondPoints; number++){
++-
++- complexVal1 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
++- complexVectorPtr += 32;
++- complexVal2 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
++- complexVectorPtr += 32;
++-
++- complexVal1 = _mm256_shuffle_epi8(complexVal1, moveMask1);
++- complexVal2 = _mm256_shuffle_epi8(complexVal2, moveMask2);
++- outputVal = _mm256_or_si256(complexVal1, complexVal2);
++- outputVal = _mm256_permute4x64_epi64(outputVal, 0xd8);
++-
++- _mm256_storeu_si256((__m256i*)iBufferPtr, outputVal);
++- iBufferPtr += 32;
++- }
++-
++- number = thirtysecondPoints * 32;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = *complexVectorPtr++;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ int8_t* iBufferPtr = iBuffer;
+++ __m256i moveMask1 = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0);
+++ __m256i moveMask2 = _mm256_set_epi8(14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80);
+++ __m256i complexVal1, complexVal2, outputVal;
+++
+++ unsigned int thirtysecondPoints = num_points / 32;
+++
+++ for (number = 0; number < thirtysecondPoints; number++) {
+++
+++ complexVal1 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal2 = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++
+++ complexVal1 = _mm256_shuffle_epi8(complexVal1, moveMask1);
+++ complexVal2 = _mm256_shuffle_epi8(complexVal2, moveMask2);
+++ outputVal = _mm256_or_si256(complexVal1, complexVal2);
+++ outputVal = _mm256_permute4x64_epi64(outputVal, 0xd8);
+++
+++ _mm256_storeu_si256((__m256i*)iBufferPtr, outputVal);
+++ iBufferPtr += 32;
+++ }
+++
+++ number = thirtysecondPoints * 32;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = *complexVectorPtr++;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_8ic_s32f_deinterleave_32f_x2.h b/kernels/volk/volk_8ic_s32f_deinterleave_32f_x2.h
++index 736f7c0..f622752 100644
++--- a/kernels/volk/volk_8ic_s32f_deinterleave_32f_x2.h
+++++ b/kernels/volk/volk_8ic_s32f_deinterleave_32f_x2.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_8ic_s32f_deinterleave_32f_x2(float* iBuffer, float* qBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points)
++- * \endcode
+++ * void volk_8ic_s32f_deinterleave_32f_x2(float* iBuffer, float* qBuffer, const lv_8sc_t*
+++ * complexVector, const float scalar, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -56,74 +56,79 @@
++ #ifndef INCLUDED_volk_8ic_s32f_deinterleave_32f_x2_a_H
++ #define INCLUDED_volk_8ic_s32f_deinterleave_32f_x2_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++ static inline void
++-volk_8ic_s32f_deinterleave_32f_x2_a_sse4_1(float* iBuffer, float* qBuffer, const lv_8sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_8ic_s32f_deinterleave_32f_x2_a_sse4_1(float* iBuffer,
+++ float* qBuffer,
+++ const lv_8sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
++-
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++- __m128 iFloatValue, qFloatValue;
++-
++- const float iScalar= 1.0 / scalar;
++- __m128 invScalar = _mm_set_ps1(iScalar);
++- __m128i complexVal, iIntVal, qIntVal, iComplexVal, qComplexVal;
++- int8_t* complexVectorPtr = (int8_t*)complexVector;
++-
++- __m128i iMoveMask = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
++- __m128i qMoveMask = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 15, 13, 11, 9, 7, 5, 3, 1);
++-
++- for(;number < eighthPoints; number++){
++- complexVal = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 16;
++- iComplexVal = _mm_shuffle_epi8(complexVal, iMoveMask);
++- qComplexVal = _mm_shuffle_epi8(complexVal, qMoveMask);
++-
++- iIntVal = _mm_cvtepi8_epi32(iComplexVal);
++- iFloatValue = _mm_cvtepi32_ps(iIntVal);
++- iFloatValue = _mm_mul_ps(iFloatValue, invScalar);
++- _mm_store_ps(iBufferPtr, iFloatValue);
++- iBufferPtr += 4;
++-
++- iComplexVal = _mm_srli_si128(iComplexVal, 4);
++-
++- iIntVal = _mm_cvtepi8_epi32(iComplexVal);
++- iFloatValue = _mm_cvtepi32_ps(iIntVal);
++- iFloatValue = _mm_mul_ps(iFloatValue, invScalar);
++- _mm_store_ps(iBufferPtr, iFloatValue);
++- iBufferPtr += 4;
++-
++- qIntVal = _mm_cvtepi8_epi32(qComplexVal);
++- qFloatValue = _mm_cvtepi32_ps(qIntVal);
++- qFloatValue = _mm_mul_ps(qFloatValue, invScalar);
++- _mm_store_ps(qBufferPtr, qFloatValue);
++- qBufferPtr += 4;
++-
++- qComplexVal = _mm_srli_si128(qComplexVal, 4);
++-
++- qIntVal = _mm_cvtepi8_epi32(qComplexVal);
++- qFloatValue = _mm_cvtepi32_ps(qIntVal);
++- qFloatValue = _mm_mul_ps(qFloatValue, invScalar);
++- _mm_store_ps(qBufferPtr, qFloatValue);
++-
++- qBufferPtr += 4;
++- }
++-
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
++- *qBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
++- }
++-
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
+++
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++ __m128 iFloatValue, qFloatValue;
+++
+++ const float iScalar = 1.0 / scalar;
+++ __m128 invScalar = _mm_set_ps1(iScalar);
+++ __m128i complexVal, iIntVal, qIntVal, iComplexVal, qComplexVal;
+++ int8_t* complexVectorPtr = (int8_t*)complexVector;
+++
+++ __m128i iMoveMask = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
+++ __m128i qMoveMask = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 15, 13, 11, 9, 7, 5, 3, 1);
+++
+++ for (; number < eighthPoints; number++) {
+++ complexVal = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++ iComplexVal = _mm_shuffle_epi8(complexVal, iMoveMask);
+++ qComplexVal = _mm_shuffle_epi8(complexVal, qMoveMask);
+++
+++ iIntVal = _mm_cvtepi8_epi32(iComplexVal);
+++ iFloatValue = _mm_cvtepi32_ps(iIntVal);
+++ iFloatValue = _mm_mul_ps(iFloatValue, invScalar);
+++ _mm_store_ps(iBufferPtr, iFloatValue);
+++ iBufferPtr += 4;
+++
+++ iComplexVal = _mm_srli_si128(iComplexVal, 4);
+++
+++ iIntVal = _mm_cvtepi8_epi32(iComplexVal);
+++ iFloatValue = _mm_cvtepi32_ps(iIntVal);
+++ iFloatValue = _mm_mul_ps(iFloatValue, invScalar);
+++ _mm_store_ps(iBufferPtr, iFloatValue);
+++ iBufferPtr += 4;
+++
+++ qIntVal = _mm_cvtepi8_epi32(qComplexVal);
+++ qFloatValue = _mm_cvtepi32_ps(qIntVal);
+++ qFloatValue = _mm_mul_ps(qFloatValue, invScalar);
+++ _mm_store_ps(qBufferPtr, qFloatValue);
+++ qBufferPtr += 4;
+++
+++ qComplexVal = _mm_srli_si128(qComplexVal, 4);
+++
+++ qIntVal = _mm_cvtepi8_epi32(qComplexVal);
+++ qFloatValue = _mm_cvtepi32_ps(qIntVal);
+++ qFloatValue = _mm_mul_ps(qFloatValue, invScalar);
+++ _mm_store_ps(qBufferPtr, qFloatValue);
+++
+++ qBufferPtr += 4;
+++ }
+++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
+++ *qBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++@@ -131,59 +136,60 @@ volk_8ic_s32f_deinterleave_32f_x2_a_sse4_1(float* iBuffer, float* qBuffer, const
++ #ifdef LV_HAVE_SSE
++ #include <xmmintrin.h>
++
++-static inline void
++-volk_8ic_s32f_deinterleave_32f_x2_a_sse(float* iBuffer, float* qBuffer,
++- const lv_8sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_8ic_s32f_deinterleave_32f_x2_a_sse(float* iBuffer,
+++ float* qBuffer,
+++ const lv_8sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
++
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++- __m128 cplxValue1, cplxValue2, iValue, qValue;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++ __m128 cplxValue1, cplxValue2, iValue, qValue;
++
++- __m128 invScalar = _mm_set_ps1(1.0/scalar);
++- int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ __m128 invScalar = _mm_set_ps1(1.0 / scalar);
+++ int8_t* complexVectorPtr = (int8_t*)complexVector;
++
++- __VOLK_ATTR_ALIGNED(16) float floatBuffer[8];
+++ __VOLK_ATTR_ALIGNED(16) float floatBuffer[8];
++
++- for(;number < quarterPoints; number++){
++- floatBuffer[0] = (float)(complexVectorPtr[0]);
++- floatBuffer[1] = (float)(complexVectorPtr[1]);
++- floatBuffer[2] = (float)(complexVectorPtr[2]);
++- floatBuffer[3] = (float)(complexVectorPtr[3]);
+++ for (; number < quarterPoints; number++) {
+++ floatBuffer[0] = (float)(complexVectorPtr[0]);
+++ floatBuffer[1] = (float)(complexVectorPtr[1]);
+++ floatBuffer[2] = (float)(complexVectorPtr[2]);
+++ floatBuffer[3] = (float)(complexVectorPtr[3]);
++
++- floatBuffer[4] = (float)(complexVectorPtr[4]);
++- floatBuffer[5] = (float)(complexVectorPtr[5]);
++- floatBuffer[6] = (float)(complexVectorPtr[6]);
++- floatBuffer[7] = (float)(complexVectorPtr[7]);
+++ floatBuffer[4] = (float)(complexVectorPtr[4]);
+++ floatBuffer[5] = (float)(complexVectorPtr[5]);
+++ floatBuffer[6] = (float)(complexVectorPtr[6]);
+++ floatBuffer[7] = (float)(complexVectorPtr[7]);
++
++- cplxValue1 = _mm_load_ps(&floatBuffer[0]);
++- cplxValue2 = _mm_load_ps(&floatBuffer[4]);
+++ cplxValue1 = _mm_load_ps(&floatBuffer[0]);
+++ cplxValue2 = _mm_load_ps(&floatBuffer[4]);
++
++- complexVectorPtr += 8;
+++ complexVectorPtr += 8;
++
++- cplxValue1 = _mm_mul_ps(cplxValue1, invScalar);
++- cplxValue2 = _mm_mul_ps(cplxValue2, invScalar);
+++ cplxValue1 = _mm_mul_ps(cplxValue1, invScalar);
+++ cplxValue2 = _mm_mul_ps(cplxValue2, invScalar);
++
++- // Arrange in i1i2i3i4 format
++- iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2,0,2,0));
++- qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3,1,3,1));
+++ // Arrange in i1i2i3i4 format
+++ iValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(2, 0, 2, 0));
+++ qValue = _mm_shuffle_ps(cplxValue1, cplxValue2, _MM_SHUFFLE(3, 1, 3, 1));
++
++- _mm_store_ps(iBufferPtr, iValue);
++- _mm_store_ps(qBufferPtr, qValue);
+++ _mm_store_ps(iBufferPtr, iValue);
+++ _mm_store_ps(qBufferPtr, qValue);
++
++- iBufferPtr += 4;
++- qBufferPtr += 4;
++- }
+++ iBufferPtr += 4;
+++ qBufferPtr += 4;
+++ }
++
++- number = quarterPoints * 4;
++- complexVectorPtr = (int8_t*)&complexVector[number];
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
++- *qBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
++- }
+++ number = quarterPoints * 4;
+++ complexVectorPtr = (int8_t*)&complexVector[number];
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
+++ *qBufferPtr++ = (float)(*complexVectorPtr++) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -191,70 +197,127 @@ volk_8ic_s32f_deinterleave_32f_x2_a_sse(float* iBuffer, float* qBuffer,
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8ic_s32f_deinterleave_32f_x2_a_avx2(float* iBuffer, float* qBuffer, const lv_8sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_8ic_s32f_deinterleave_32f_x2_a_avx2(float* iBuffer,
+++ float* qBuffer,
+++ const lv_8sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++- __m256 iFloatValue, qFloatValue;
++-
++- const float iScalar= 1.0 / scalar;
++- __m256 invScalar = _mm256_set1_ps(iScalar);
++- __m256i complexVal, iIntVal, qIntVal, iComplexVal, qComplexVal;
++- int8_t* complexVectorPtr = (int8_t*)complexVector;
++-
++- __m256i iMoveMask = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
++- 14, 12, 10, 8, 6, 4, 2, 0,
++- 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
++- 14, 12, 10, 8, 6, 4, 2, 0);
++- __m256i qMoveMask = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
++- 15, 13, 11, 9, 7, 5, 3, 1,
++- 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
++- 15, 13, 11, 9, 7, 5, 3, 1);
++-
++- for(;number < sixteenthPoints; number++){
++- complexVal = _mm256_load_si256((__m256i*)complexVectorPtr);
++- complexVectorPtr += 32;
++- iComplexVal = _mm256_shuffle_epi8(complexVal, iMoveMask);
++- qComplexVal = _mm256_shuffle_epi8(complexVal, qMoveMask);
++-
++- iIntVal = _mm256_cvtepi8_epi32(_mm256_castsi256_si128(iComplexVal));
++- iFloatValue = _mm256_cvtepi32_ps(iIntVal);
++- iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
++- _mm256_store_ps(iBufferPtr, iFloatValue);
++- iBufferPtr += 8;
++-
++- iComplexVal = _mm256_permute4x64_epi64(iComplexVal, 0b11000110);
++- iIntVal = _mm256_cvtepi8_epi32(_mm256_castsi256_si128(iComplexVal));
++- iFloatValue = _mm256_cvtepi32_ps(iIntVal);
++- iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
++- _mm256_store_ps(iBufferPtr, iFloatValue);
++- iBufferPtr += 8;
++-
++- qIntVal = _mm256_cvtepi8_epi32(_mm256_castsi256_si128(qComplexVal));
++- qFloatValue = _mm256_cvtepi32_ps(qIntVal);
++- qFloatValue = _mm256_mul_ps(qFloatValue, invScalar);
++- _mm256_store_ps(qBufferPtr, qFloatValue);
++- qBufferPtr += 8;
++-
++- qComplexVal = _mm256_permute4x64_epi64(qComplexVal, 0b11000110);
++- qIntVal = _mm256_cvtepi8_epi32(_mm256_castsi256_si128(qComplexVal));
++- qFloatValue = _mm256_cvtepi32_ps(qIntVal);
++- qFloatValue = _mm256_mul_ps(qFloatValue, invScalar);
++- _mm256_store_ps(qBufferPtr, qFloatValue);
++- qBufferPtr += 8;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
++- *qBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
++- }
++-
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++ __m256 iFloatValue, qFloatValue;
+++
+++ const float iScalar = 1.0 / scalar;
+++ __m256 invScalar = _mm256_set1_ps(iScalar);
+++ __m256i complexVal, iIntVal, qIntVal, iComplexVal, qComplexVal;
+++ int8_t* complexVectorPtr = (int8_t*)complexVector;
+++
+++ __m256i iMoveMask = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0);
+++ __m256i qMoveMask = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 15,
+++ 13,
+++ 11,
+++ 9,
+++ 7,
+++ 5,
+++ 3,
+++ 1,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 15,
+++ 13,
+++ 11,
+++ 9,
+++ 7,
+++ 5,
+++ 3,
+++ 1);
+++
+++ for (; number < sixteenthPoints; number++) {
+++ complexVal = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ iComplexVal = _mm256_shuffle_epi8(complexVal, iMoveMask);
+++ qComplexVal = _mm256_shuffle_epi8(complexVal, qMoveMask);
+++
+++ iIntVal = _mm256_cvtepi8_epi32(_mm256_castsi256_si128(iComplexVal));
+++ iFloatValue = _mm256_cvtepi32_ps(iIntVal);
+++ iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
+++ _mm256_store_ps(iBufferPtr, iFloatValue);
+++ iBufferPtr += 8;
+++
+++ iComplexVal = _mm256_permute4x64_epi64(iComplexVal, 0b11000110);
+++ iIntVal = _mm256_cvtepi8_epi32(_mm256_castsi256_si128(iComplexVal));
+++ iFloatValue = _mm256_cvtepi32_ps(iIntVal);
+++ iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
+++ _mm256_store_ps(iBufferPtr, iFloatValue);
+++ iBufferPtr += 8;
+++
+++ qIntVal = _mm256_cvtepi8_epi32(_mm256_castsi256_si128(qComplexVal));
+++ qFloatValue = _mm256_cvtepi32_ps(qIntVal);
+++ qFloatValue = _mm256_mul_ps(qFloatValue, invScalar);
+++ _mm256_store_ps(qBufferPtr, qFloatValue);
+++ qBufferPtr += 8;
+++
+++ qComplexVal = _mm256_permute4x64_epi64(qComplexVal, 0b11000110);
+++ qIntVal = _mm256_cvtepi8_epi32(_mm256_castsi256_si128(qComplexVal));
+++ qFloatValue = _mm256_cvtepi32_ps(qIntVal);
+++ qFloatValue = _mm256_mul_ps(qFloatValue, invScalar);
+++ _mm256_store_ps(qBufferPtr, qFloatValue);
+++ qBufferPtr += 8;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
+++ *qBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -262,19 +325,21 @@ volk_8ic_s32f_deinterleave_32f_x2_a_avx2(float* iBuffer, float* qBuffer, const l
++ #ifdef LV_HAVE_GENERIC
++
++ static inline void
++-volk_8ic_s32f_deinterleave_32f_x2_generic(float* iBuffer, float* qBuffer,
+++volk_8ic_s32f_deinterleave_32f_x2_generic(float* iBuffer,
+++ float* qBuffer,
++ const lv_8sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- const int8_t* complexVectorPtr = (const int8_t*)complexVector;
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
++- unsigned int number;
++- const float invScalar = 1.0 / scalar;
++- for(number = 0; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++)*invScalar;
++- *qBufferPtr++ = (float)(*complexVectorPtr++)*invScalar;
++- }
+++ const int8_t* complexVectorPtr = (const int8_t*)complexVector;
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
+++ unsigned int number;
+++ const float invScalar = 1.0 / scalar;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) * invScalar;
+++ *qBufferPtr++ = (float)(*complexVectorPtr++) * invScalar;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -285,75 +350,107 @@ volk_8ic_s32f_deinterleave_32f_x2_generic(float* iBuffer, float* qBuffer,
++ #ifndef INCLUDED_volk_8ic_s32f_deinterleave_32f_x2_u_H
++ #define INCLUDED_volk_8ic_s32f_deinterleave_32f_x2_u_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8ic_s32f_deinterleave_32f_x2_u_avx2(float* iBuffer, float* qBuffer, const lv_8sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++static inline void volk_8ic_s32f_deinterleave_32f_x2_u_avx2(float* iBuffer,
+++ float* qBuffer,
+++ const lv_8sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++- float* qBufferPtr = qBuffer;
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++- __m256 iFloatValue, qFloatValue;
++-
++- const float iScalar= 1.0 / scalar;
++- __m256 invScalar = _mm256_set1_ps(iScalar);
++- __m256i complexVal, iIntVal, qIntVal;
++- __m128i iComplexVal, qComplexVal;
++- int8_t* complexVectorPtr = (int8_t*)complexVector;
++-
++- __m256i MoveMask = _mm256_set_epi8(15, 13, 11, 9, 7, 5, 3, 1, 14, 12, 10, 8,
++- 6, 4, 2, 0,15, 13, 11, 9, 7, 5, 3, 1, 14, 12, 10, 8, 6, 4, 2, 0);
++-
++- for(;number < sixteenthPoints; number++){
++- complexVal = _mm256_loadu_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++- complexVal = _mm256_shuffle_epi8(complexVal, MoveMask);
++- complexVal = _mm256_permute4x64_epi64(complexVal,0xd8);
++- iComplexVal = _mm256_extractf128_si256(complexVal,0);
++- qComplexVal = _mm256_extractf128_si256(complexVal,1);
++-
++- iIntVal = _mm256_cvtepi8_epi32(iComplexVal);
++- iFloatValue = _mm256_cvtepi32_ps(iIntVal);
++- iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
++- _mm256_storeu_ps(iBufferPtr, iFloatValue);
++- iBufferPtr += 8;
++-
++- qIntVal = _mm256_cvtepi8_epi32(qComplexVal);
++- qFloatValue = _mm256_cvtepi32_ps(qIntVal);
++- qFloatValue = _mm256_mul_ps(qFloatValue, invScalar);
++- _mm256_storeu_ps(qBufferPtr, qFloatValue);
++- qBufferPtr += 8;
++-
++- complexVal = _mm256_srli_si256(complexVal, 8);
++- iComplexVal = _mm256_extractf128_si256(complexVal,0);
++- qComplexVal = _mm256_extractf128_si256(complexVal,1);
++-
++- iIntVal = _mm256_cvtepi8_epi32(iComplexVal);
++- iFloatValue = _mm256_cvtepi32_ps(iIntVal);
++- iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
++- _mm256_storeu_ps(iBufferPtr, iFloatValue);
++- iBufferPtr += 8;
++-
++- qIntVal = _mm256_cvtepi8_epi32(qComplexVal);
++- qFloatValue = _mm256_cvtepi32_ps(qIntVal);
++- qFloatValue = _mm256_mul_ps(qFloatValue, invScalar);
++- _mm256_storeu_ps(qBufferPtr, qFloatValue);
++- qBufferPtr += 8;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
++- *qBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
++- }
++-
+++ float* iBufferPtr = iBuffer;
+++ float* qBufferPtr = qBuffer;
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++ __m256 iFloatValue, qFloatValue;
+++
+++ const float iScalar = 1.0 / scalar;
+++ __m256 invScalar = _mm256_set1_ps(iScalar);
+++ __m256i complexVal, iIntVal, qIntVal;
+++ __m128i iComplexVal, qComplexVal;
+++ int8_t* complexVectorPtr = (int8_t*)complexVector;
+++
+++ __m256i MoveMask = _mm256_set_epi8(15,
+++ 13,
+++ 11,
+++ 9,
+++ 7,
+++ 5,
+++ 3,
+++ 1,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 15,
+++ 13,
+++ 11,
+++ 9,
+++ 7,
+++ 5,
+++ 3,
+++ 1,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0);
+++
+++ for (; number < sixteenthPoints; number++) {
+++ complexVal = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal = _mm256_shuffle_epi8(complexVal, MoveMask);
+++ complexVal = _mm256_permute4x64_epi64(complexVal, 0xd8);
+++ iComplexVal = _mm256_extractf128_si256(complexVal, 0);
+++ qComplexVal = _mm256_extractf128_si256(complexVal, 1);
+++
+++ iIntVal = _mm256_cvtepi8_epi32(iComplexVal);
+++ iFloatValue = _mm256_cvtepi32_ps(iIntVal);
+++ iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
+++ _mm256_storeu_ps(iBufferPtr, iFloatValue);
+++ iBufferPtr += 8;
+++
+++ qIntVal = _mm256_cvtepi8_epi32(qComplexVal);
+++ qFloatValue = _mm256_cvtepi32_ps(qIntVal);
+++ qFloatValue = _mm256_mul_ps(qFloatValue, invScalar);
+++ _mm256_storeu_ps(qBufferPtr, qFloatValue);
+++ qBufferPtr += 8;
+++
+++ complexVal = _mm256_srli_si256(complexVal, 8);
+++ iComplexVal = _mm256_extractf128_si256(complexVal, 0);
+++ qComplexVal = _mm256_extractf128_si256(complexVal, 1);
+++
+++ iIntVal = _mm256_cvtepi8_epi32(iComplexVal);
+++ iFloatValue = _mm256_cvtepi32_ps(iIntVal);
+++ iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
+++ _mm256_storeu_ps(iBufferPtr, iFloatValue);
+++ iBufferPtr += 8;
+++
+++ qIntVal = _mm256_cvtepi8_epi32(qComplexVal);
+++ qFloatValue = _mm256_cvtepi32_ps(qIntVal);
+++ qFloatValue = _mm256_mul_ps(qFloatValue, invScalar);
+++ _mm256_storeu_ps(qBufferPtr, qFloatValue);
+++ qBufferPtr += 8;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
+++ *qBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_8ic_s32f_deinterleave_real_32f.h b/kernels/volk/volk_8ic_s32f_deinterleave_real_32f.h
++index 0c85ee9..4c1afe7 100644
++--- a/kernels/volk/volk_8ic_s32f_deinterleave_real_32f.h
+++++ b/kernels/volk/volk_8ic_s32f_deinterleave_real_32f.h
++@@ -31,8 +31,8 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_8ic_s32f_deinterleave_real_32f(float* iBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points)
++- * \endcode
+++ * void volk_8ic_s32f_deinterleave_real_32f(float* iBuffer, const lv_8sc_t* complexVector,
+++ * const float scalar, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li complexVector: The complex input vector.
++@@ -55,57 +55,86 @@
++ #ifndef INCLUDED_volk_8ic_s32f_deinterleave_real_32f_a_H
++ #define INCLUDED_volk_8ic_s32f_deinterleave_real_32f_a_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++ static inline void
++-volk_8ic_s32f_deinterleave_real_32f_a_avx2(float* iBuffer, const lv_8sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_8ic_s32f_deinterleave_real_32f_a_avx2(float* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++- __m256 iFloatValue;
++-
++- const float iScalar= 1.0 / scalar;
++- __m256 invScalar = _mm256_set1_ps(iScalar);
++- __m256i complexVal, iIntVal;
++- int8_t* complexVectorPtr = (int8_t*)complexVector;
++-
++- __m256i moveMask = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
++- 14, 12, 10, 8, 6, 4, 2, 0,
++- 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
++- 14, 12, 10, 8, 6, 4, 2, 0);
++- for(;number < sixteenthPoints; number++){
++- complexVal = _mm256_load_si256((__m256i*)complexVectorPtr);
++- complexVectorPtr += 32;
++- complexVal = _mm256_shuffle_epi8(complexVal, moveMask);
++-
++- iIntVal = _mm256_cvtepi8_epi32(_mm256_castsi256_si128(complexVal));
++- iFloatValue = _mm256_cvtepi32_ps(iIntVal);
++- iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
++- _mm256_store_ps(iBufferPtr, iFloatValue);
++- iBufferPtr += 8;
++-
++- complexVal = _mm256_permute4x64_epi64(complexVal, 0b11000110);
++- iIntVal = _mm256_cvtepi8_epi32(_mm256_castsi256_si128(complexVal));
++- iFloatValue = _mm256_cvtepi32_ps(iIntVal);
++- iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
++- _mm256_store_ps(iBufferPtr, iFloatValue);
++- iBufferPtr += 8;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
++- complexVectorPtr++;
++- }
++-
+++ float* iBufferPtr = iBuffer;
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++ __m256 iFloatValue;
+++
+++ const float iScalar = 1.0 / scalar;
+++ __m256 invScalar = _mm256_set1_ps(iScalar);
+++ __m256i complexVal, iIntVal;
+++ int8_t* complexVectorPtr = (int8_t*)complexVector;
+++
+++ __m256i moveMask = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0);
+++ for (; number < sixteenthPoints; number++) {
+++ complexVal = _mm256_load_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal = _mm256_shuffle_epi8(complexVal, moveMask);
+++
+++ iIntVal = _mm256_cvtepi8_epi32(_mm256_castsi256_si128(complexVal));
+++ iFloatValue = _mm256_cvtepi32_ps(iIntVal);
+++ iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
+++ _mm256_store_ps(iBufferPtr, iFloatValue);
+++ iBufferPtr += 8;
+++
+++ complexVal = _mm256_permute4x64_epi64(complexVal, 0b11000110);
+++ iIntVal = _mm256_cvtepi8_epi32(_mm256_castsi256_si128(complexVal));
+++ iFloatValue = _mm256_cvtepi32_ps(iIntVal);
+++ iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
+++ _mm256_store_ps(iBufferPtr, iFloatValue);
+++ iBufferPtr += 8;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -114,52 +143,55 @@ volk_8ic_s32f_deinterleave_real_32f_a_avx2(float* iBuffer, const lv_8sc_t* compl
++ #include <smmintrin.h>
++
++ static inline void
++-volk_8ic_s32f_deinterleave_real_32f_a_sse4_1(float* iBuffer, const lv_8sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_8ic_s32f_deinterleave_real_32f_a_sse4_1(float* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++-
++- unsigned int number = 0;
++- const unsigned int eighthPoints = num_points / 8;
++- __m128 iFloatValue;
+++ float* iBufferPtr = iBuffer;
++
++- const float iScalar= 1.0 / scalar;
++- __m128 invScalar = _mm_set_ps1(iScalar);
++- __m128i complexVal, iIntVal;
++- int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ unsigned int number = 0;
+++ const unsigned int eighthPoints = num_points / 8;
+++ __m128 iFloatValue;
++
++- __m128i moveMask = _mm_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
+++ const float iScalar = 1.0 / scalar;
+++ __m128 invScalar = _mm_set_ps1(iScalar);
+++ __m128i complexVal, iIntVal;
+++ int8_t* complexVectorPtr = (int8_t*)complexVector;
++
++- for(;number < eighthPoints; number++){
++- complexVal = _mm_load_si128((__m128i*)complexVectorPtr); complexVectorPtr += 16;
++- complexVal = _mm_shuffle_epi8(complexVal, moveMask);
+++ __m128i moveMask = _mm_set_epi8(
+++ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
++
++- iIntVal = _mm_cvtepi8_epi32(complexVal);
++- iFloatValue = _mm_cvtepi32_ps(iIntVal);
+++ for (; number < eighthPoints; number++) {
+++ complexVal = _mm_load_si128((__m128i*)complexVectorPtr);
+++ complexVectorPtr += 16;
+++ complexVal = _mm_shuffle_epi8(complexVal, moveMask);
++
++- iFloatValue = _mm_mul_ps(iFloatValue, invScalar);
+++ iIntVal = _mm_cvtepi8_epi32(complexVal);
+++ iFloatValue = _mm_cvtepi32_ps(iIntVal);
++
++- _mm_store_ps(iBufferPtr, iFloatValue);
+++ iFloatValue = _mm_mul_ps(iFloatValue, invScalar);
++
++- iBufferPtr += 4;
+++ _mm_store_ps(iBufferPtr, iFloatValue);
++
++- complexVal = _mm_srli_si128(complexVal, 4);
++- iIntVal = _mm_cvtepi8_epi32(complexVal);
++- iFloatValue = _mm_cvtepi32_ps(iIntVal);
+++ iBufferPtr += 4;
++
++- iFloatValue = _mm_mul_ps(iFloatValue, invScalar);
+++ complexVal = _mm_srli_si128(complexVal, 4);
+++ iIntVal = _mm_cvtepi8_epi32(complexVal);
+++ iFloatValue = _mm_cvtepi32_ps(iIntVal);
++
++- _mm_store_ps(iBufferPtr, iFloatValue);
+++ iFloatValue = _mm_mul_ps(iFloatValue, invScalar);
++
++- iBufferPtr += 4;
++- }
+++ _mm_store_ps(iBufferPtr, iFloatValue);
++
++- number = eighthPoints * 8;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
++- complexVectorPtr++;
++- }
+++ iBufferPtr += 4;
+++ }
++
+++ number = eighthPoints * 8;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++@@ -168,42 +200,47 @@ volk_8ic_s32f_deinterleave_real_32f_a_sse4_1(float* iBuffer, const lv_8sc_t* com
++ #include <xmmintrin.h>
++
++ static inline void
++-volk_8ic_s32f_deinterleave_real_32f_a_sse(float* iBuffer, const lv_8sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_8ic_s32f_deinterleave_real_32f_a_sse(float* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++-
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++- __m128 iValue;
+++ float* iBufferPtr = iBuffer;
++
++- const float iScalar= 1.0 / scalar;
++- __m128 invScalar = _mm_set_ps1(iScalar);
++- int8_t* complexVectorPtr = (int8_t*)complexVector;
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++ __m128 iValue;
++
++- __VOLK_ATTR_ALIGNED(16) float floatBuffer[4];
+++ const float iScalar = 1.0 / scalar;
+++ __m128 invScalar = _mm_set_ps1(iScalar);
+++ int8_t* complexVectorPtr = (int8_t*)complexVector;
++
++- for(;number < quarterPoints; number++){
++- floatBuffer[0] = (float)(*complexVectorPtr); complexVectorPtr += 2;
++- floatBuffer[1] = (float)(*complexVectorPtr); complexVectorPtr += 2;
++- floatBuffer[2] = (float)(*complexVectorPtr); complexVectorPtr += 2;
++- floatBuffer[3] = (float)(*complexVectorPtr); complexVectorPtr += 2;
+++ __VOLK_ATTR_ALIGNED(16) float floatBuffer[4];
++
++- iValue = _mm_load_ps(floatBuffer);
+++ for (; number < quarterPoints; number++) {
+++ floatBuffer[0] = (float)(*complexVectorPtr);
+++ complexVectorPtr += 2;
+++ floatBuffer[1] = (float)(*complexVectorPtr);
+++ complexVectorPtr += 2;
+++ floatBuffer[2] = (float)(*complexVectorPtr);
+++ complexVectorPtr += 2;
+++ floatBuffer[3] = (float)(*complexVectorPtr);
+++ complexVectorPtr += 2;
++
++- iValue = _mm_mul_ps(iValue, invScalar);
+++ iValue = _mm_load_ps(floatBuffer);
++
++- _mm_store_ps(iBufferPtr, iValue);
+++ iValue = _mm_mul_ps(iValue, invScalar);
++
++- iBufferPtr += 4;
++- }
+++ _mm_store_ps(iBufferPtr, iValue);
++
++- number = quarterPoints * 4;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
++- complexVectorPtr++;
++- }
+++ iBufferPtr += 4;
+++ }
++
+++ number = quarterPoints * 4;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_SSE */
++
++@@ -211,83 +248,117 @@ volk_8ic_s32f_deinterleave_real_32f_a_sse(float* iBuffer, const lv_8sc_t* comple
++ #ifdef LV_HAVE_GENERIC
++
++ static inline void
++-volk_8ic_s32f_deinterleave_real_32f_generic(float* iBuffer, const lv_8sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_8ic_s32f_deinterleave_real_32f_generic(float* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const int8_t* complexVectorPtr = (const int8_t*)complexVector;
++- float* iBufferPtr = iBuffer;
++- const float invScalar = 1.0 / scalar;
++- for(number = 0; number < num_points; number++){
++- *iBufferPtr++ = ((float)(*complexVectorPtr++)) * invScalar;
++- complexVectorPtr++;
++- }
+++ unsigned int number = 0;
+++ const int8_t* complexVectorPtr = (const int8_t*)complexVector;
+++ float* iBufferPtr = iBuffer;
+++ const float invScalar = 1.0 / scalar;
+++ for (number = 0; number < num_points; number++) {
+++ *iBufferPtr++ = ((float)(*complexVectorPtr++)) * invScalar;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++-
++ #endif /* INCLUDED_volk_8ic_s32f_deinterleave_real_32f_a_H */
++
++ #ifndef INCLUDED_volk_8ic_s32f_deinterleave_real_32f_u_H
++ #define INCLUDED_volk_8ic_s32f_deinterleave_real_32f_u_H
++
++-#include <volk/volk_common.h>
++ #include <inttypes.h>
++ #include <stdio.h>
+++#include <volk/volk_common.h>
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++ static inline void
++-volk_8ic_s32f_deinterleave_real_32f_u_avx2(float* iBuffer, const lv_8sc_t* complexVector,
++- const float scalar, unsigned int num_points)
+++volk_8ic_s32f_deinterleave_real_32f_u_avx2(float* iBuffer,
+++ const lv_8sc_t* complexVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- float* iBufferPtr = iBuffer;
++-
++- unsigned int number = 0;
++- const unsigned int sixteenthPoints = num_points / 16;
++- __m256 iFloatValue;
++-
++- const float iScalar= 1.0 / scalar;
++- __m256 invScalar = _mm256_set1_ps(iScalar);
++- __m256i complexVal, iIntVal;
++- __m128i hcomplexVal;
++- int8_t* complexVectorPtr = (int8_t*)complexVector;
++-
++- __m256i moveMask = _mm256_set_epi8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 14, 12, 10, 8, 6, 4, 2, 0);
++-
++- for(;number < sixteenthPoints; number++){
++- complexVal = _mm256_loadu_si256((__m256i*)complexVectorPtr); complexVectorPtr += 32;
++- complexVal = _mm256_shuffle_epi8(complexVal, moveMask);
++-
++- hcomplexVal = _mm256_extracti128_si256(complexVal,0);
++- iIntVal = _mm256_cvtepi8_epi32(hcomplexVal);
++- iFloatValue = _mm256_cvtepi32_ps(iIntVal);
++-
++- iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
++-
++- _mm256_storeu_ps(iBufferPtr, iFloatValue);
++-
++- iBufferPtr += 8;
++-
++- hcomplexVal = _mm256_extracti128_si256(complexVal,1);
++- iIntVal = _mm256_cvtepi8_epi32(hcomplexVal);
++- iFloatValue = _mm256_cvtepi32_ps(iIntVal);
++-
++- iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
++-
++- _mm256_storeu_ps(iBufferPtr, iFloatValue);
++-
++- iBufferPtr += 8;
++- }
++-
++- number = sixteenthPoints * 16;
++- for(; number < num_points; number++){
++- *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
++- complexVectorPtr++;
++- }
++-
+++ float* iBufferPtr = iBuffer;
+++
+++ unsigned int number = 0;
+++ const unsigned int sixteenthPoints = num_points / 16;
+++ __m256 iFloatValue;
+++
+++ const float iScalar = 1.0 / scalar;
+++ __m256 invScalar = _mm256_set1_ps(iScalar);
+++ __m256i complexVal, iIntVal;
+++ __m128i hcomplexVal;
+++ int8_t* complexVectorPtr = (int8_t*)complexVector;
+++
+++ __m256i moveMask = _mm256_set_epi8(0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 0x80,
+++ 14,
+++ 12,
+++ 10,
+++ 8,
+++ 6,
+++ 4,
+++ 2,
+++ 0);
+++
+++ for (; number < sixteenthPoints; number++) {
+++ complexVal = _mm256_loadu_si256((__m256i*)complexVectorPtr);
+++ complexVectorPtr += 32;
+++ complexVal = _mm256_shuffle_epi8(complexVal, moveMask);
+++
+++ hcomplexVal = _mm256_extracti128_si256(complexVal, 0);
+++ iIntVal = _mm256_cvtepi8_epi32(hcomplexVal);
+++ iFloatValue = _mm256_cvtepi32_ps(iIntVal);
+++
+++ iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
+++
+++ _mm256_storeu_ps(iBufferPtr, iFloatValue);
+++
+++ iBufferPtr += 8;
+++
+++ hcomplexVal = _mm256_extracti128_si256(complexVal, 1);
+++ iIntVal = _mm256_cvtepi8_epi32(hcomplexVal);
+++ iFloatValue = _mm256_cvtepi32_ps(iIntVal);
+++
+++ iFloatValue = _mm256_mul_ps(iFloatValue, invScalar);
+++
+++ _mm256_storeu_ps(iBufferPtr, iFloatValue);
+++
+++ iBufferPtr += 8;
+++ }
+++
+++ number = sixteenthPoints * 16;
+++ for (; number < num_points; number++) {
+++ *iBufferPtr++ = (float)(*complexVectorPtr++) * iScalar;
+++ complexVectorPtr++;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_8ic_x2_multiply_conjugate_16ic.h b/kernels/volk/volk_8ic_x2_multiply_conjugate_16ic.h
++index 6762658..7f9fd96 100644
++--- a/kernels/volk/volk_8ic_x2_multiply_conjugate_16ic.h
+++++ b/kernels/volk/volk_8ic_x2_multiply_conjugate_16ic.h
++@@ -30,64 +30,73 @@
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++ /*!
++- \brief Multiplys the one complex vector with the complex conjugate of the second complex vector and stores their results in the third vector
++- \param cVector The complex vector where the results will be stored
++- \param aVector One of the complex vectors to be multiplied
++- \param bVector The complex vector which will be converted to complex conjugate and multiplied
++- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector
+++ \brief Multiplys the one complex vector with the complex conjugate of the second complex
+++ vector and stores their results in the third vector \param cVector The complex vector
+++ where the results will be stored \param aVector One of the complex vectors to be
+++ multiplied \param bVector The complex vector which will be converted to complex
+++ conjugate and multiplied \param num_points The number of complex values in aVector and
+++ bVector to be multiplied together and stored into cVector
++ */
++-static inline void volk_8ic_x2_multiply_conjugate_16ic_a_avx2(lv_16sc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, unsigned int num_points){
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 8;
++-
++- __m256i x, y, realz, imagz;
++- lv_16sc_t* c = cVector;
++- const lv_8sc_t* a = aVector;
++- const lv_8sc_t* b = bVector;
++- __m256i conjugateSign = _mm256_set_epi16(-1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1);
++-
++- for(;number < quarterPoints; number++){
++- // Convert 8 bit values into 16 bit values
++- x = _mm256_cvtepi8_epi16(_mm_load_si128((__m128i*)a));
++- y = _mm256_cvtepi8_epi16(_mm_load_si128((__m128i*)b));
++-
++- // Calculate the ar*cr - ai*(-ci) portions
++- realz = _mm256_madd_epi16(x,y);
++-
++- // Calculate the complex conjugate of the cr + ci j values
++- y = _mm256_sign_epi16(y, conjugateSign);
++-
++- // Shift the order of the cr and ci values
++- y = _mm256_shufflehi_epi16(_mm256_shufflelo_epi16(y, _MM_SHUFFLE(2,3,0,1) ), _MM_SHUFFLE(2,3,0,1));
++-
++- // Calculate the ar*(-ci) + cr*(ai)
++- imagz = _mm256_madd_epi16(x,y);
++-
++- // Perform the addition of products
++-
++- _mm256_store_si256((__m256i*)c, _mm256_packs_epi32(_mm256_unpacklo_epi32(realz, imagz), _mm256_unpackhi_epi32(realz, imagz)));
++-
++- a += 8;
++- b += 8;
++- c += 8;
++- }
++-
++- number = quarterPoints * 8;
++- int16_t* c16Ptr = (int16_t*)&cVector[number];
++- int8_t* a8Ptr = (int8_t*)&aVector[number];
++- int8_t* b8Ptr = (int8_t*)&bVector[number];
++- for(; number < num_points; number++){
++- float aReal = (float)*a8Ptr++;
++- float aImag = (float)*a8Ptr++;
++- lv_32fc_t aVal = lv_cmake(aReal, aImag );
++- float bReal = (float)*b8Ptr++;
++- float bImag = (float)*b8Ptr++;
++- lv_32fc_t bVal = lv_cmake( bReal, -bImag );
++- lv_32fc_t temp = aVal * bVal;
++-
++- *c16Ptr++ = (int16_t)lv_creal(temp);
++- *c16Ptr++ = (int16_t)lv_cimag(temp);
++- }
+++static inline void volk_8ic_x2_multiply_conjugate_16ic_a_avx2(lv_16sc_t* cVector,
+++ const lv_8sc_t* aVector,
+++ const lv_8sc_t* bVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 8;
+++
+++ __m256i x, y, realz, imagz;
+++ lv_16sc_t* c = cVector;
+++ const lv_8sc_t* a = aVector;
+++ const lv_8sc_t* b = bVector;
+++ __m256i conjugateSign =
+++ _mm256_set_epi16(-1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1);
+++
+++ for (; number < quarterPoints; number++) {
+++ // Convert 8 bit values into 16 bit values
+++ x = _mm256_cvtepi8_epi16(_mm_load_si128((__m128i*)a));
+++ y = _mm256_cvtepi8_epi16(_mm_load_si128((__m128i*)b));
+++
+++ // Calculate the ar*cr - ai*(-ci) portions
+++ realz = _mm256_madd_epi16(x, y);
+++
+++ // Calculate the complex conjugate of the cr + ci j values
+++ y = _mm256_sign_epi16(y, conjugateSign);
+++
+++ // Shift the order of the cr and ci values
+++ y = _mm256_shufflehi_epi16(_mm256_shufflelo_epi16(y, _MM_SHUFFLE(2, 3, 0, 1)),
+++ _MM_SHUFFLE(2, 3, 0, 1));
+++
+++ // Calculate the ar*(-ci) + cr*(ai)
+++ imagz = _mm256_madd_epi16(x, y);
+++
+++ // Perform the addition of products
+++
+++ _mm256_store_si256((__m256i*)c,
+++ _mm256_packs_epi32(_mm256_unpacklo_epi32(realz, imagz),
+++ _mm256_unpackhi_epi32(realz, imagz)));
+++
+++ a += 8;
+++ b += 8;
+++ c += 8;
+++ }
+++
+++ number = quarterPoints * 8;
+++ int16_t* c16Ptr = (int16_t*)&cVector[number];
+++ int8_t* a8Ptr = (int8_t*)&aVector[number];
+++ int8_t* b8Ptr = (int8_t*)&bVector[number];
+++ for (; number < num_points; number++) {
+++ float aReal = (float)*a8Ptr++;
+++ float aImag = (float)*a8Ptr++;
+++ lv_32fc_t aVal = lv_cmake(aReal, aImag);
+++ float bReal = (float)*b8Ptr++;
+++ float bImag = (float)*b8Ptr++;
+++ lv_32fc_t bVal = lv_cmake(bReal, -bImag);
+++ lv_32fc_t temp = aVal * bVal;
+++
+++ *c16Ptr++ = (int16_t)lv_creal(temp);
+++ *c16Ptr++ = (int16_t)lv_cimag(temp);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -95,90 +104,103 @@ static inline void volk_8ic_x2_multiply_conjugate_16ic_a_avx2(lv_16sc_t* cVector
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++ /*!
++- \brief Multiplys the one complex vector with the complex conjugate of the second complex vector and stores their results in the third vector
++- \param cVector The complex vector where the results will be stored
++- \param aVector One of the complex vectors to be multiplied
++- \param bVector The complex vector which will be converted to complex conjugate and multiplied
++- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector
+++ \brief Multiplys the one complex vector with the complex conjugate of the second complex
+++ vector and stores their results in the third vector \param cVector The complex vector
+++ where the results will be stored \param aVector One of the complex vectors to be
+++ multiplied \param bVector The complex vector which will be converted to complex
+++ conjugate and multiplied \param num_points The number of complex values in aVector and
+++ bVector to be multiplied together and stored into cVector
++ */
++-static inline void volk_8ic_x2_multiply_conjugate_16ic_a_sse4_1(lv_16sc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, unsigned int num_points){
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- __m128i x, y, realz, imagz;
++- lv_16sc_t* c = cVector;
++- const lv_8sc_t* a = aVector;
++- const lv_8sc_t* b = bVector;
++- __m128i conjugateSign = _mm_set_epi16(-1, 1, -1, 1, -1, 1, -1, 1);
++-
++- for(;number < quarterPoints; number++){
++- // Convert into 8 bit values into 16 bit values
++- x = _mm_cvtepi8_epi16(_mm_loadl_epi64((__m128i*)a));
++- y = _mm_cvtepi8_epi16(_mm_loadl_epi64((__m128i*)b));
++-
++- // Calculate the ar*cr - ai*(-ci) portions
++- realz = _mm_madd_epi16(x,y);
++-
++- // Calculate the complex conjugate of the cr + ci j values
++- y = _mm_sign_epi16(y, conjugateSign);
++-
++- // Shift the order of the cr and ci values
++- y = _mm_shufflehi_epi16(_mm_shufflelo_epi16(y, _MM_SHUFFLE(2,3,0,1) ), _MM_SHUFFLE(2,3,0,1));
++-
++- // Calculate the ar*(-ci) + cr*(ai)
++- imagz = _mm_madd_epi16(x,y);
++-
++- _mm_store_si128((__m128i*)c, _mm_packs_epi32(_mm_unpacklo_epi32(realz, imagz), _mm_unpackhi_epi32(realz, imagz)));
++-
++- a += 4;
++- b += 4;
++- c += 4;
++- }
++-
++- number = quarterPoints * 4;
++- int16_t* c16Ptr = (int16_t*)&cVector[number];
++- int8_t* a8Ptr = (int8_t*)&aVector[number];
++- int8_t* b8Ptr = (int8_t*)&bVector[number];
++- for(; number < num_points; number++){
++- float aReal = (float)*a8Ptr++;
++- float aImag = (float)*a8Ptr++;
++- lv_32fc_t aVal = lv_cmake(aReal, aImag );
++- float bReal = (float)*b8Ptr++;
++- float bImag = (float)*b8Ptr++;
++- lv_32fc_t bVal = lv_cmake( bReal, -bImag );
++- lv_32fc_t temp = aVal * bVal;
++-
++- *c16Ptr++ = (int16_t)lv_creal(temp);
++- *c16Ptr++ = (int16_t)lv_cimag(temp);
++- }
+++static inline void volk_8ic_x2_multiply_conjugate_16ic_a_sse4_1(lv_16sc_t* cVector,
+++ const lv_8sc_t* aVector,
+++ const lv_8sc_t* bVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ __m128i x, y, realz, imagz;
+++ lv_16sc_t* c = cVector;
+++ const lv_8sc_t* a = aVector;
+++ const lv_8sc_t* b = bVector;
+++ __m128i conjugateSign = _mm_set_epi16(-1, 1, -1, 1, -1, 1, -1, 1);
+++
+++ for (; number < quarterPoints; number++) {
+++ // Convert into 8 bit values into 16 bit values
+++ x = _mm_cvtepi8_epi16(_mm_loadl_epi64((__m128i*)a));
+++ y = _mm_cvtepi8_epi16(_mm_loadl_epi64((__m128i*)b));
+++
+++ // Calculate the ar*cr - ai*(-ci) portions
+++ realz = _mm_madd_epi16(x, y);
+++
+++ // Calculate the complex conjugate of the cr + ci j values
+++ y = _mm_sign_epi16(y, conjugateSign);
+++
+++ // Shift the order of the cr and ci values
+++ y = _mm_shufflehi_epi16(_mm_shufflelo_epi16(y, _MM_SHUFFLE(2, 3, 0, 1)),
+++ _MM_SHUFFLE(2, 3, 0, 1));
+++
+++ // Calculate the ar*(-ci) + cr*(ai)
+++ imagz = _mm_madd_epi16(x, y);
+++
+++ _mm_store_si128((__m128i*)c,
+++ _mm_packs_epi32(_mm_unpacklo_epi32(realz, imagz),
+++ _mm_unpackhi_epi32(realz, imagz)));
+++
+++ a += 4;
+++ b += 4;
+++ c += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ int16_t* c16Ptr = (int16_t*)&cVector[number];
+++ int8_t* a8Ptr = (int8_t*)&aVector[number];
+++ int8_t* b8Ptr = (int8_t*)&bVector[number];
+++ for (; number < num_points; number++) {
+++ float aReal = (float)*a8Ptr++;
+++ float aImag = (float)*a8Ptr++;
+++ lv_32fc_t aVal = lv_cmake(aReal, aImag);
+++ float bReal = (float)*b8Ptr++;
+++ float bImag = (float)*b8Ptr++;
+++ lv_32fc_t bVal = lv_cmake(bReal, -bImag);
+++ lv_32fc_t temp = aVal * bVal;
+++
+++ *c16Ptr++ = (int16_t)lv_creal(temp);
+++ *c16Ptr++ = (int16_t)lv_cimag(temp);
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++ #ifdef LV_HAVE_GENERIC
++ /*!
++- \brief Multiplys the one complex vector with the complex conjugate of the second complex vector and stores their results in the third vector
++- \param cVector The complex vector where the results will be stored
++- \param aVector One of the complex vectors to be multiplied
++- \param bVector The complex vector which will be converted to complex conjugate and multiplied
++- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector
+++ \brief Multiplys the one complex vector with the complex conjugate of the second complex
+++ vector and stores their results in the third vector \param cVector The complex vector
+++ where the results will be stored \param aVector One of the complex vectors to be
+++ multiplied \param bVector The complex vector which will be converted to complex
+++ conjugate and multiplied \param num_points The number of complex values in aVector and
+++ bVector to be multiplied together and stored into cVector
++ */
++-static inline void volk_8ic_x2_multiply_conjugate_16ic_generic(lv_16sc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, unsigned int num_points){
++- unsigned int number = 0;
++- int16_t* c16Ptr = (int16_t*)cVector;
++- int8_t* a8Ptr = (int8_t*)aVector;
++- int8_t* b8Ptr = (int8_t*)bVector;
++- for(number =0; number < num_points; number++){
++- float aReal = (float)*a8Ptr++;
++- float aImag = (float)*a8Ptr++;
++- lv_32fc_t aVal = lv_cmake(aReal, aImag );
++- float bReal = (float)*b8Ptr++;
++- float bImag = (float)*b8Ptr++;
++- lv_32fc_t bVal = lv_cmake( bReal, -bImag );
++- lv_32fc_t temp = aVal * bVal;
++-
++- *c16Ptr++ = (int16_t)lv_creal(temp);
++- *c16Ptr++ = (int16_t)lv_cimag(temp);
++- }
+++static inline void volk_8ic_x2_multiply_conjugate_16ic_generic(lv_16sc_t* cVector,
+++ const lv_8sc_t* aVector,
+++ const lv_8sc_t* bVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ int16_t* c16Ptr = (int16_t*)cVector;
+++ int8_t* a8Ptr = (int8_t*)aVector;
+++ int8_t* b8Ptr = (int8_t*)bVector;
+++ for (number = 0; number < num_points; number++) {
+++ float aReal = (float)*a8Ptr++;
+++ float aImag = (float)*a8Ptr++;
+++ lv_32fc_t aVal = lv_cmake(aReal, aImag);
+++ float bReal = (float)*b8Ptr++;
+++ float bImag = (float)*b8Ptr++;
+++ lv_32fc_t bVal = lv_cmake(bReal, -bImag);
+++ lv_32fc_t temp = aVal * bVal;
+++
+++ *c16Ptr++ = (int16_t)lv_creal(temp);
+++ *c16Ptr++ = (int16_t)lv_cimag(temp);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -194,64 +216,73 @@ static inline void volk_8ic_x2_multiply_conjugate_16ic_generic(lv_16sc_t* cVecto
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++ /*!
++- \brief Multiplys the one complex vector with the complex conjugate of the second complex vector and stores their results in the third vector
++- \param cVector The complex vector where the results will be stored
++- \param aVector One of the complex vectors to be multiplied
++- \param bVector The complex vector which will be converted to complex conjugate and multiplied
++- \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector
+++ \brief Multiplys the one complex vector with the complex conjugate of the second complex
+++ vector and stores their results in the third vector \param cVector The complex vector
+++ where the results will be stored \param aVector One of the complex vectors to be
+++ multiplied \param bVector The complex vector which will be converted to complex
+++ conjugate and multiplied \param num_points The number of complex values in aVector and
+++ bVector to be multiplied together and stored into cVector
++ */
++-static inline void volk_8ic_x2_multiply_conjugate_16ic_u_avx2(lv_16sc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, unsigned int num_points){
++- unsigned int number = 0;
++- const unsigned int oneEigthPoints = num_points / 8;
++-
++- __m256i x, y, realz, imagz;
++- lv_16sc_t* c = cVector;
++- const lv_8sc_t* a = aVector;
++- const lv_8sc_t* b = bVector;
++- __m256i conjugateSign = _mm256_set_epi16(-1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1);
++-
++- for(;number < oneEigthPoints; number++){
++- // Convert 8 bit values into 16 bit values
++- x = _mm256_cvtepi8_epi16(_mm_loadu_si128((__m128i*)a));
++- y = _mm256_cvtepi8_epi16(_mm_loadu_si128((__m128i*)b));
++-
++- // Calculate the ar*cr - ai*(-ci) portions
++- realz = _mm256_madd_epi16(x,y);
++-
++- // Calculate the complex conjugate of the cr + ci j values
++- y = _mm256_sign_epi16(y, conjugateSign);
++-
++- // Shift the order of the cr and ci values
++- y = _mm256_shufflehi_epi16(_mm256_shufflelo_epi16(y, _MM_SHUFFLE(2,3,0,1) ), _MM_SHUFFLE(2,3,0,1));
++-
++- // Calculate the ar*(-ci) + cr*(ai)
++- imagz = _mm256_madd_epi16(x,y);
++-
++- // Perform the addition of products
++-
++- _mm256_storeu_si256((__m256i*)c, _mm256_packs_epi32(_mm256_unpacklo_epi32(realz, imagz), _mm256_unpackhi_epi32(realz, imagz)));
++-
++- a += 8;
++- b += 8;
++- c += 8;
++- }
++-
++- number = oneEigthPoints * 8;
++- int16_t* c16Ptr = (int16_t*)&cVector[number];
++- int8_t* a8Ptr = (int8_t*)&aVector[number];
++- int8_t* b8Ptr = (int8_t*)&bVector[number];
++- for(; number < num_points; number++){
++- float aReal = (float)*a8Ptr++;
++- float aImag = (float)*a8Ptr++;
++- lv_32fc_t aVal = lv_cmake(aReal, aImag );
++- float bReal = (float)*b8Ptr++;
++- float bImag = (float)*b8Ptr++;
++- lv_32fc_t bVal = lv_cmake( bReal, -bImag );
++- lv_32fc_t temp = aVal * bVal;
++-
++- *c16Ptr++ = (int16_t)lv_creal(temp);
++- *c16Ptr++ = (int16_t)lv_cimag(temp);
++- }
+++static inline void volk_8ic_x2_multiply_conjugate_16ic_u_avx2(lv_16sc_t* cVector,
+++ const lv_8sc_t* aVector,
+++ const lv_8sc_t* bVector,
+++ unsigned int num_points)
+++{
+++ unsigned int number = 0;
+++ const unsigned int oneEigthPoints = num_points / 8;
+++
+++ __m256i x, y, realz, imagz;
+++ lv_16sc_t* c = cVector;
+++ const lv_8sc_t* a = aVector;
+++ const lv_8sc_t* b = bVector;
+++ __m256i conjugateSign =
+++ _mm256_set_epi16(-1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1);
+++
+++ for (; number < oneEigthPoints; number++) {
+++ // Convert 8 bit values into 16 bit values
+++ x = _mm256_cvtepi8_epi16(_mm_loadu_si128((__m128i*)a));
+++ y = _mm256_cvtepi8_epi16(_mm_loadu_si128((__m128i*)b));
+++
+++ // Calculate the ar*cr - ai*(-ci) portions
+++ realz = _mm256_madd_epi16(x, y);
+++
+++ // Calculate the complex conjugate of the cr + ci j values
+++ y = _mm256_sign_epi16(y, conjugateSign);
+++
+++ // Shift the order of the cr and ci values
+++ y = _mm256_shufflehi_epi16(_mm256_shufflelo_epi16(y, _MM_SHUFFLE(2, 3, 0, 1)),
+++ _MM_SHUFFLE(2, 3, 0, 1));
+++
+++ // Calculate the ar*(-ci) + cr*(ai)
+++ imagz = _mm256_madd_epi16(x, y);
+++
+++ // Perform the addition of products
+++
+++ _mm256_storeu_si256((__m256i*)c,
+++ _mm256_packs_epi32(_mm256_unpacklo_epi32(realz, imagz),
+++ _mm256_unpackhi_epi32(realz, imagz)));
+++
+++ a += 8;
+++ b += 8;
+++ c += 8;
+++ }
+++
+++ number = oneEigthPoints * 8;
+++ int16_t* c16Ptr = (int16_t*)&cVector[number];
+++ int8_t* a8Ptr = (int8_t*)&aVector[number];
+++ int8_t* b8Ptr = (int8_t*)&bVector[number];
+++ for (; number < num_points; number++) {
+++ float aReal = (float)*a8Ptr++;
+++ float aImag = (float)*a8Ptr++;
+++ lv_32fc_t aVal = lv_cmake(aReal, aImag);
+++ float bReal = (float)*b8Ptr++;
+++ float bImag = (float)*b8Ptr++;
+++ lv_32fc_t bVal = lv_cmake(bReal, -bImag);
+++ lv_32fc_t temp = aVal * bVal;
+++
+++ *c16Ptr++ = (int16_t)lv_creal(temp);
+++ *c16Ptr++ = (int16_t)lv_cimag(temp);
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_8ic_x2_s32f_multiply_conjugate_32fc.h b/kernels/volk/volk_8ic_x2_s32f_multiply_conjugate_32fc.h
++index 82e40c8..db6bd7a 100644
++--- a/kernels/volk/volk_8ic_x2_s32f_multiply_conjugate_32fc.h
+++++ b/kernels/volk/volk_8ic_x2_s32f_multiply_conjugate_32fc.h
++@@ -30,14 +30,15 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_8ic_x2_s32f_multiply_conjugate_32fc(lv_32fc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, const float scalar, unsigned int num_points)
++- * \endcode
+++ * void volk_8ic_x2_s32f_multiply_conjugate_32fc(lv_32fc_t* cVector, const lv_8sc_t*
+++ * aVector, const lv_8sc_t* bVector, const float scalar, unsigned int num_points) \endcode
++ *
++ * \b Inputs
++ * \li aVector: One of the complex vectors to be multiplied.
++- * \li bVector: The complex vector which will be converted to complex conjugate and multiplied.
++- * \li scalar: each output value is scaled by 1/scalar.
++- * \li num_points: The number of complex values in aVector and bVector to be multiplied together and stored into cVector.
+++ * \li bVector: The complex vector which will be converted to complex conjugate and
+++ * multiplied. \li scalar: each output value is scaled by 1/scalar. \li num_points: The
+++ * number of complex values in aVector and bVector to be multiplied together and stored
+++ * into cVector.
++ *
++ * \b Outputs
++ * \li cVector: The complex vector where the results will be stored.
++@@ -64,160 +65,167 @@
++ #include <immintrin.h>
++
++ static inline void
++-volk_8ic_x2_s32f_multiply_conjugate_32fc_a_avx2(lv_32fc_t* cVector, const lv_8sc_t* aVector,
++- const lv_8sc_t* bVector, const float scalar,
++- unsigned int num_points)
+++volk_8ic_x2_s32f_multiply_conjugate_32fc_a_avx2(lv_32fc_t* cVector,
+++ const lv_8sc_t* aVector,
+++ const lv_8sc_t* bVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int oneEigthPoints = num_points / 8;
++-
++- __m256i x, y, realz, imagz;
++- __m256 ret, retlo, rethi;
++- lv_32fc_t* c = cVector;
++- const lv_8sc_t* a = aVector;
++- const lv_8sc_t* b = bVector;
++- __m256i conjugateSign = _mm256_set_epi16(-1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1);
++-
++- __m256 invScalar = _mm256_set1_ps(1.0/scalar);
++-
++- for(;number < oneEigthPoints; number++){
++- // Convert 8 bit values into 16 bit values
++- x = _mm256_cvtepi8_epi16(_mm_load_si128((__m128i*)a));
++- y = _mm256_cvtepi8_epi16(_mm_load_si128((__m128i*)b));
++-
++- // Calculate the ar*cr - ai*(-ci) portions
++- realz = _mm256_madd_epi16(x,y);
++-
++- // Calculate the complex conjugate of the cr + ci j values
++- y = _mm256_sign_epi16(y, conjugateSign);
++-
++- // Shift the order of the cr and ci values
++- y = _mm256_shufflehi_epi16(_mm256_shufflelo_epi16(y, _MM_SHUFFLE(2,3,0,1) ), _MM_SHUFFLE(2,3,0,1));
++-
++- // Calculate the ar*(-ci) + cr*(ai)
++- imagz = _mm256_madd_epi16(x,y);
++-
++- // Interleave real and imaginary and then convert to float values
++- retlo = _mm256_cvtepi32_ps(_mm256_unpacklo_epi32(realz, imagz));
++-
++- // Normalize the floating point values
++- retlo = _mm256_mul_ps(retlo, invScalar);
++-
++- // Interleave real and imaginary and then convert to float values
++- rethi = _mm256_cvtepi32_ps(_mm256_unpackhi_epi32(realz, imagz));
++-
++- // Normalize the floating point values
++- rethi = _mm256_mul_ps(rethi, invScalar);
++-
++- ret = _mm256_permute2f128_ps(retlo, rethi, 0b00100000);
++- _mm256_store_ps((float*)c, ret);
++- c += 4;
++-
++- ret = _mm256_permute2f128_ps(retlo, rethi, 0b00110001);
++- _mm256_store_ps((float*)c, ret);
++- c += 4;
++-
++- a += 8;
++- b += 8;
++- }
++-
++- number = oneEigthPoints * 8;
++- float* cFloatPtr = (float*)&cVector[number];
++- int8_t* a8Ptr = (int8_t*)&aVector[number];
++- int8_t* b8Ptr = (int8_t*)&bVector[number];
++- for(; number < num_points; number++){
++- float aReal = (float)*a8Ptr++;
++- float aImag = (float)*a8Ptr++;
++- lv_32fc_t aVal = lv_cmake(aReal, aImag );
++- float bReal = (float)*b8Ptr++;
++- float bImag = (float)*b8Ptr++;
++- lv_32fc_t bVal = lv_cmake( bReal, -bImag );
++- lv_32fc_t temp = aVal * bVal;
++-
++- *cFloatPtr++ = lv_creal(temp) / scalar;
++- *cFloatPtr++ = lv_cimag(temp) / scalar;
++- }
+++ unsigned int number = 0;
+++ const unsigned int oneEigthPoints = num_points / 8;
+++
+++ __m256i x, y, realz, imagz;
+++ __m256 ret, retlo, rethi;
+++ lv_32fc_t* c = cVector;
+++ const lv_8sc_t* a = aVector;
+++ const lv_8sc_t* b = bVector;
+++ __m256i conjugateSign =
+++ _mm256_set_epi16(-1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1);
+++
+++ __m256 invScalar = _mm256_set1_ps(1.0 / scalar);
+++
+++ for (; number < oneEigthPoints; number++) {
+++ // Convert 8 bit values into 16 bit values
+++ x = _mm256_cvtepi8_epi16(_mm_load_si128((__m128i*)a));
+++ y = _mm256_cvtepi8_epi16(_mm_load_si128((__m128i*)b));
+++
+++ // Calculate the ar*cr - ai*(-ci) portions
+++ realz = _mm256_madd_epi16(x, y);
+++
+++ // Calculate the complex conjugate of the cr + ci j values
+++ y = _mm256_sign_epi16(y, conjugateSign);
+++
+++ // Shift the order of the cr and ci values
+++ y = _mm256_shufflehi_epi16(_mm256_shufflelo_epi16(y, _MM_SHUFFLE(2, 3, 0, 1)),
+++ _MM_SHUFFLE(2, 3, 0, 1));
+++
+++ // Calculate the ar*(-ci) + cr*(ai)
+++ imagz = _mm256_madd_epi16(x, y);
+++
+++ // Interleave real and imaginary and then convert to float values
+++ retlo = _mm256_cvtepi32_ps(_mm256_unpacklo_epi32(realz, imagz));
+++
+++ // Normalize the floating point values
+++ retlo = _mm256_mul_ps(retlo, invScalar);
+++
+++ // Interleave real and imaginary and then convert to float values
+++ rethi = _mm256_cvtepi32_ps(_mm256_unpackhi_epi32(realz, imagz));
+++
+++ // Normalize the floating point values
+++ rethi = _mm256_mul_ps(rethi, invScalar);
+++
+++ ret = _mm256_permute2f128_ps(retlo, rethi, 0b00100000);
+++ _mm256_store_ps((float*)c, ret);
+++ c += 4;
+++
+++ ret = _mm256_permute2f128_ps(retlo, rethi, 0b00110001);
+++ _mm256_store_ps((float*)c, ret);
+++ c += 4;
+++
+++ a += 8;
+++ b += 8;
+++ }
+++
+++ number = oneEigthPoints * 8;
+++ float* cFloatPtr = (float*)&cVector[number];
+++ int8_t* a8Ptr = (int8_t*)&aVector[number];
+++ int8_t* b8Ptr = (int8_t*)&bVector[number];
+++ for (; number < num_points; number++) {
+++ float aReal = (float)*a8Ptr++;
+++ float aImag = (float)*a8Ptr++;
+++ lv_32fc_t aVal = lv_cmake(aReal, aImag);
+++ float bReal = (float)*b8Ptr++;
+++ float bImag = (float)*b8Ptr++;
+++ lv_32fc_t bVal = lv_cmake(bReal, -bImag);
+++ lv_32fc_t temp = aVal * bVal;
+++
+++ *cFloatPtr++ = lv_creal(temp) / scalar;
+++ *cFloatPtr++ = lv_cimag(temp) / scalar;
+++ }
++ }
++-#endif /* LV_HAVE_AVX2*/
+++#endif /* LV_HAVE_AVX2*/
++
++
++ #ifdef LV_HAVE_SSE4_1
++ #include <smmintrin.h>
++
++ static inline void
++-volk_8ic_x2_s32f_multiply_conjugate_32fc_a_sse4_1(lv_32fc_t* cVector, const lv_8sc_t* aVector,
++- const lv_8sc_t* bVector, const float scalar,
+++volk_8ic_x2_s32f_multiply_conjugate_32fc_a_sse4_1(lv_32fc_t* cVector,
+++ const lv_8sc_t* aVector,
+++ const lv_8sc_t* bVector,
+++ const float scalar,
++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int quarterPoints = num_points / 4;
++-
++- __m128i x, y, realz, imagz;
++- __m128 ret;
++- lv_32fc_t* c = cVector;
++- const lv_8sc_t* a = aVector;
++- const lv_8sc_t* b = bVector;
++- __m128i conjugateSign = _mm_set_epi16(-1, 1, -1, 1, -1, 1, -1, 1);
++-
++- __m128 invScalar = _mm_set_ps1(1.0/scalar);
++-
++- for(;number < quarterPoints; number++){
++- // Convert into 8 bit values into 16 bit values
++- x = _mm_cvtepi8_epi16(_mm_loadl_epi64((__m128i*)a));
++- y = _mm_cvtepi8_epi16(_mm_loadl_epi64((__m128i*)b));
++-
++- // Calculate the ar*cr - ai*(-ci) portions
++- realz = _mm_madd_epi16(x,y);
++-
++- // Calculate the complex conjugate of the cr + ci j values
++- y = _mm_sign_epi16(y, conjugateSign);
++-
++- // Shift the order of the cr and ci values
++- y = _mm_shufflehi_epi16(_mm_shufflelo_epi16(y, _MM_SHUFFLE(2,3,0,1) ), _MM_SHUFFLE(2,3,0,1));
++-
++- // Calculate the ar*(-ci) + cr*(ai)
++- imagz = _mm_madd_epi16(x,y);
++-
++- // Interleave real and imaginary and then convert to float values
++- ret = _mm_cvtepi32_ps(_mm_unpacklo_epi32(realz, imagz));
++-
++- // Normalize the floating point values
++- ret = _mm_mul_ps(ret, invScalar);
++-
++- // Store the floating point values
++- _mm_store_ps((float*)c, ret);
++- c += 2;
++-
++- // Interleave real and imaginary and then convert to float values
++- ret = _mm_cvtepi32_ps(_mm_unpackhi_epi32(realz, imagz));
++-
++- // Normalize the floating point values
++- ret = _mm_mul_ps(ret, invScalar);
++-
++- // Store the floating point values
++- _mm_store_ps((float*)c, ret);
++- c += 2;
++-
++- a += 4;
++- b += 4;
++- }
++-
++- number = quarterPoints * 4;
++- float* cFloatPtr = (float*)&cVector[number];
++- int8_t* a8Ptr = (int8_t*)&aVector[number];
++- int8_t* b8Ptr = (int8_t*)&bVector[number];
++- for(; number < num_points; number++){
++- float aReal = (float)*a8Ptr++;
++- float aImag = (float)*a8Ptr++;
++- lv_32fc_t aVal = lv_cmake(aReal, aImag );
++- float bReal = (float)*b8Ptr++;
++- float bImag = (float)*b8Ptr++;
++- lv_32fc_t bVal = lv_cmake( bReal, -bImag );
++- lv_32fc_t temp = aVal * bVal;
++-
++- *cFloatPtr++ = lv_creal(temp) / scalar;
++- *cFloatPtr++ = lv_cimag(temp) / scalar;
++- }
+++ unsigned int number = 0;
+++ const unsigned int quarterPoints = num_points / 4;
+++
+++ __m128i x, y, realz, imagz;
+++ __m128 ret;
+++ lv_32fc_t* c = cVector;
+++ const lv_8sc_t* a = aVector;
+++ const lv_8sc_t* b = bVector;
+++ __m128i conjugateSign = _mm_set_epi16(-1, 1, -1, 1, -1, 1, -1, 1);
+++
+++ __m128 invScalar = _mm_set_ps1(1.0 / scalar);
+++
+++ for (; number < quarterPoints; number++) {
+++ // Convert into 8 bit values into 16 bit values
+++ x = _mm_cvtepi8_epi16(_mm_loadl_epi64((__m128i*)a));
+++ y = _mm_cvtepi8_epi16(_mm_loadl_epi64((__m128i*)b));
+++
+++ // Calculate the ar*cr - ai*(-ci) portions
+++ realz = _mm_madd_epi16(x, y);
+++
+++ // Calculate the complex conjugate of the cr + ci j values
+++ y = _mm_sign_epi16(y, conjugateSign);
+++
+++ // Shift the order of the cr and ci values
+++ y = _mm_shufflehi_epi16(_mm_shufflelo_epi16(y, _MM_SHUFFLE(2, 3, 0, 1)),
+++ _MM_SHUFFLE(2, 3, 0, 1));
+++
+++ // Calculate the ar*(-ci) + cr*(ai)
+++ imagz = _mm_madd_epi16(x, y);
+++
+++ // Interleave real and imaginary and then convert to float values
+++ ret = _mm_cvtepi32_ps(_mm_unpacklo_epi32(realz, imagz));
+++
+++ // Normalize the floating point values
+++ ret = _mm_mul_ps(ret, invScalar);
+++
+++ // Store the floating point values
+++ _mm_store_ps((float*)c, ret);
+++ c += 2;
+++
+++ // Interleave real and imaginary and then convert to float values
+++ ret = _mm_cvtepi32_ps(_mm_unpackhi_epi32(realz, imagz));
+++
+++ // Normalize the floating point values
+++ ret = _mm_mul_ps(ret, invScalar);
+++
+++ // Store the floating point values
+++ _mm_store_ps((float*)c, ret);
+++ c += 2;
+++
+++ a += 4;
+++ b += 4;
+++ }
+++
+++ number = quarterPoints * 4;
+++ float* cFloatPtr = (float*)&cVector[number];
+++ int8_t* a8Ptr = (int8_t*)&aVector[number];
+++ int8_t* b8Ptr = (int8_t*)&bVector[number];
+++ for (; number < num_points; number++) {
+++ float aReal = (float)*a8Ptr++;
+++ float aImag = (float)*a8Ptr++;
+++ lv_32fc_t aVal = lv_cmake(aReal, aImag);
+++ float bReal = (float)*b8Ptr++;
+++ float bImag = (float)*b8Ptr++;
+++ lv_32fc_t bVal = lv_cmake(bReal, -bImag);
+++ lv_32fc_t temp = aVal * bVal;
+++
+++ *cFloatPtr++ = lv_creal(temp) / scalar;
+++ *cFloatPtr++ = lv_cimag(temp) / scalar;
+++ }
++ }
++ #endif /* LV_HAVE_SSE4_1 */
++
++@@ -225,27 +233,29 @@ volk_8ic_x2_s32f_multiply_conjugate_32fc_a_sse4_1(lv_32fc_t* cVector, const lv_8
++ #ifdef LV_HAVE_GENERIC
++
++ static inline void
++-volk_8ic_x2_s32f_multiply_conjugate_32fc_generic(lv_32fc_t* cVector, const lv_8sc_t* aVector,
++- const lv_8sc_t* bVector, const float scalar,
+++volk_8ic_x2_s32f_multiply_conjugate_32fc_generic(lv_32fc_t* cVector,
+++ const lv_8sc_t* aVector,
+++ const lv_8sc_t* bVector,
+++ const float scalar,
++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- float* cPtr = (float*)cVector;
++- const float invScalar = 1.0 / scalar;
++- int8_t* a8Ptr = (int8_t*)aVector;
++- int8_t* b8Ptr = (int8_t*)bVector;
++- for(number = 0; number < num_points; number++){
++- float aReal = (float)*a8Ptr++;
++- float aImag = (float)*a8Ptr++;
++- lv_32fc_t aVal = lv_cmake(aReal, aImag );
++- float bReal = (float)*b8Ptr++;
++- float bImag = (float)*b8Ptr++;
++- lv_32fc_t bVal = lv_cmake( bReal, -bImag );
++- lv_32fc_t temp = aVal * bVal;
++-
++- *cPtr++ = (lv_creal(temp) * invScalar);
++- *cPtr++ = (lv_cimag(temp) * invScalar);
++- }
+++ unsigned int number = 0;
+++ float* cPtr = (float*)cVector;
+++ const float invScalar = 1.0 / scalar;
+++ int8_t* a8Ptr = (int8_t*)aVector;
+++ int8_t* b8Ptr = (int8_t*)bVector;
+++ for (number = 0; number < num_points; number++) {
+++ float aReal = (float)*a8Ptr++;
+++ float aImag = (float)*a8Ptr++;
+++ lv_32fc_t aVal = lv_cmake(aReal, aImag);
+++ float bReal = (float)*b8Ptr++;
+++ float bImag = (float)*b8Ptr++;
+++ lv_32fc_t bVal = lv_cmake(bReal, -bImag);
+++ lv_32fc_t temp = aVal * bVal;
+++
+++ *cPtr++ = (lv_creal(temp) * invScalar);
+++ *cPtr++ = (lv_cimag(temp) * invScalar);
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -263,81 +273,85 @@ volk_8ic_x2_s32f_multiply_conjugate_32fc_generic(lv_32fc_t* cVector, const lv_8s
++ #include <immintrin.h>
++
++ static inline void
++-volk_8ic_x2_s32f_multiply_conjugate_32fc_u_avx2(lv_32fc_t* cVector, const lv_8sc_t* aVector,
++- const lv_8sc_t* bVector, const float scalar,
++- unsigned int num_points)
+++volk_8ic_x2_s32f_multiply_conjugate_32fc_u_avx2(lv_32fc_t* cVector,
+++ const lv_8sc_t* aVector,
+++ const lv_8sc_t* bVector,
+++ const float scalar,
+++ unsigned int num_points)
++ {
++- unsigned int number = 0;
++- const unsigned int oneEigthPoints = num_points / 8;
++-
++- __m256i x, y, realz, imagz;
++- __m256 ret, retlo, rethi;
++- lv_32fc_t* c = cVector;
++- const lv_8sc_t* a = aVector;
++- const lv_8sc_t* b = bVector;
++- __m256i conjugateSign = _mm256_set_epi16(-1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1);
++-
++- __m256 invScalar = _mm256_set1_ps(1.0/scalar);
++-
++- for(;number < oneEigthPoints; number++){
++- // Convert 8 bit values into 16 bit values
++- x = _mm256_cvtepi8_epi16(_mm_loadu_si128((__m128i*)a));
++- y = _mm256_cvtepi8_epi16(_mm_loadu_si128((__m128i*)b));
++-
++- // Calculate the ar*cr - ai*(-ci) portions
++- realz = _mm256_madd_epi16(x,y);
++-
++- // Calculate the complex conjugate of the cr + ci j values
++- y = _mm256_sign_epi16(y, conjugateSign);
++-
++- // Shift the order of the cr and ci values
++- y = _mm256_shufflehi_epi16(_mm256_shufflelo_epi16(y, _MM_SHUFFLE(2,3,0,1) ), _MM_SHUFFLE(2,3,0,1));
++-
++- // Calculate the ar*(-ci) + cr*(ai)
++- imagz = _mm256_madd_epi16(x,y);
++-
++- // Interleave real and imaginary and then convert to float values
++- retlo = _mm256_cvtepi32_ps(_mm256_unpacklo_epi32(realz, imagz));
++-
++- // Normalize the floating point values
++- retlo = _mm256_mul_ps(retlo, invScalar);
++-
++- // Interleave real and imaginary and then convert to float values
++- rethi = _mm256_cvtepi32_ps(_mm256_unpackhi_epi32(realz, imagz));
++-
++- // Normalize the floating point values
++- rethi = _mm256_mul_ps(rethi, invScalar);
++-
++- ret = _mm256_permute2f128_ps(retlo, rethi, 0b00100000);
++- _mm256_storeu_ps((float*)c, ret);
++- c += 4;
++-
++- ret = _mm256_permute2f128_ps(retlo, rethi, 0b00110001);
++- _mm256_storeu_ps((float*)c, ret);
++- c += 4;
++-
++- a += 8;
++- b += 8;
++- }
++-
++- number = oneEigthPoints * 8;
++- float* cFloatPtr = (float*)&cVector[number];
++- int8_t* a8Ptr = (int8_t*)&aVector[number];
++- int8_t* b8Ptr = (int8_t*)&bVector[number];
++- for(; number < num_points; number++){
++- float aReal = (float)*a8Ptr++;
++- float aImag = (float)*a8Ptr++;
++- lv_32fc_t aVal = lv_cmake(aReal, aImag );
++- float bReal = (float)*b8Ptr++;
++- float bImag = (float)*b8Ptr++;
++- lv_32fc_t bVal = lv_cmake( bReal, -bImag );
++- lv_32fc_t temp = aVal * bVal;
++-
++- *cFloatPtr++ = lv_creal(temp) / scalar;
++- *cFloatPtr++ = lv_cimag(temp) / scalar;
++- }
+++ unsigned int number = 0;
+++ const unsigned int oneEigthPoints = num_points / 8;
+++
+++ __m256i x, y, realz, imagz;
+++ __m256 ret, retlo, rethi;
+++ lv_32fc_t* c = cVector;
+++ const lv_8sc_t* a = aVector;
+++ const lv_8sc_t* b = bVector;
+++ __m256i conjugateSign =
+++ _mm256_set_epi16(-1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1);
+++
+++ __m256 invScalar = _mm256_set1_ps(1.0 / scalar);
+++
+++ for (; number < oneEigthPoints; number++) {
+++ // Convert 8 bit values into 16 bit values
+++ x = _mm256_cvtepi8_epi16(_mm_loadu_si128((__m128i*)a));
+++ y = _mm256_cvtepi8_epi16(_mm_loadu_si128((__m128i*)b));
+++
+++ // Calculate the ar*cr - ai*(-ci) portions
+++ realz = _mm256_madd_epi16(x, y);
+++
+++ // Calculate the complex conjugate of the cr + ci j values
+++ y = _mm256_sign_epi16(y, conjugateSign);
+++
+++ // Shift the order of the cr and ci values
+++ y = _mm256_shufflehi_epi16(_mm256_shufflelo_epi16(y, _MM_SHUFFLE(2, 3, 0, 1)),
+++ _MM_SHUFFLE(2, 3, 0, 1));
+++
+++ // Calculate the ar*(-ci) + cr*(ai)
+++ imagz = _mm256_madd_epi16(x, y);
+++
+++ // Interleave real and imaginary and then convert to float values
+++ retlo = _mm256_cvtepi32_ps(_mm256_unpacklo_epi32(realz, imagz));
+++
+++ // Normalize the floating point values
+++ retlo = _mm256_mul_ps(retlo, invScalar);
+++
+++ // Interleave real and imaginary and then convert to float values
+++ rethi = _mm256_cvtepi32_ps(_mm256_unpackhi_epi32(realz, imagz));
+++
+++ // Normalize the floating point values
+++ rethi = _mm256_mul_ps(rethi, invScalar);
+++
+++ ret = _mm256_permute2f128_ps(retlo, rethi, 0b00100000);
+++ _mm256_storeu_ps((float*)c, ret);
+++ c += 4;
+++
+++ ret = _mm256_permute2f128_ps(retlo, rethi, 0b00110001);
+++ _mm256_storeu_ps((float*)c, ret);
+++ c += 4;
+++
+++ a += 8;
+++ b += 8;
+++ }
+++
+++ number = oneEigthPoints * 8;
+++ float* cFloatPtr = (float*)&cVector[number];
+++ int8_t* a8Ptr = (int8_t*)&aVector[number];
+++ int8_t* b8Ptr = (int8_t*)&bVector[number];
+++ for (; number < num_points; number++) {
+++ float aReal = (float)*a8Ptr++;
+++ float aImag = (float)*a8Ptr++;
+++ lv_32fc_t aVal = lv_cmake(aReal, aImag);
+++ float bReal = (float)*b8Ptr++;
+++ float bImag = (float)*b8Ptr++;
+++ lv_32fc_t bVal = lv_cmake(bReal, -bImag);
+++ lv_32fc_t temp = aVal * bVal;
+++
+++ *cFloatPtr++ = lv_creal(temp) / scalar;
+++ *cFloatPtr++ = lv_cimag(temp) / scalar;
+++ }
++ }
++-#endif /* LV_HAVE_AVX2*/
+++#endif /* LV_HAVE_AVX2*/
++
++
++ #endif /* INCLUDED_volk_8ic_x2_s32f_multiply_conjugate_32fc_u_H */
++diff --git a/kernels/volk/volk_8u_conv_k7_r2puppet_8u.h b/kernels/volk/volk_8u_conv_k7_r2puppet_8u.h
++index 00f83de..69287cd 100644
++--- a/kernels/volk/volk_8u_conv_k7_r2puppet_8u.h
+++++ b/kernels/volk/volk_8u_conv_k7_r2puppet_8u.h
++@@ -23,21 +23,21 @@
++ #ifndef INCLUDED_volk_8u_conv_k7_r2puppet_8u_H
++ #define INCLUDED_volk_8u_conv_k7_r2puppet_8u_H
++
+++#include <string.h>
++ #include <volk/volk.h>
++ #include <volk/volk_8u_x4_conv_k7_r2_8u.h>
++-#include <string.h>
++
++ typedef union {
++- //decision_t is a BIT vector
++- unsigned char* t;
++- unsigned int* w;
+++ // decision_t is a BIT vector
+++ unsigned char* t;
+++ unsigned int* w;
++ } p_decision_t;
++
++ static inline int parity(int x, unsigned char* Partab)
++ {
++- x ^= (x >> 16);
++- x ^= (x >> 8);
++- return Partab[x];
+++ x ^= (x >> 16);
+++ x ^= (x >> 8);
+++ return Partab[x];
++ }
++
++ static inline int chainback_viterbi(unsigned char* data,
++@@ -46,135 +46,143 @@ static inline int chainback_viterbi(unsigned char* data,
++ unsigned int tailsize,
++ unsigned char* decisions)
++ {
++- unsigned char* d;
++- int d_ADDSHIFT = 0;
++- int d_numstates = (1 << 6);
++- int d_decision_t_size = d_numstates/8;
++- unsigned int d_k = 7;
++- int d_framebits = nbits;
++- /* ADDSHIFT and SUBSHIFT make sure that the thing returned is a byte. */
++- d = decisions;
++- /* Make room beyond the end of the encoder register so we can
++- * accumulate a full byte of decoded data
++- */
++-
++- endstate = (endstate%d_numstates) << d_ADDSHIFT;
++-
++- /* The store into data[] only needs to be done every 8 bits.
++- * But this avoids a conditional branch, and the writes will
++- * combine in the cache anyway
++- */
++-
++- d += tailsize * d_decision_t_size ; /* Look past tail */
++- int retval;
++- int dif = tailsize - (d_k - 1);
++- //printf("break, %d, %d\n", dif, (nbits+dif)%d_framebits);
++- p_decision_t dec;
++- while(nbits-- > d_framebits - (d_k - 1)) {
++- int k;
++- dec.t = &d[nbits * d_decision_t_size];
++- k = (dec.w[(endstate>>d_ADDSHIFT)/32] >> ((endstate>>d_ADDSHIFT)%32)) & 1;
++-
++- endstate = (endstate >> 1) | (k << (d_k-2+d_ADDSHIFT));
++- //data[((nbits+dif)%nbits)>>3] = endstate>>d_SUBSHIFT;
++- //printf("%d, %d\n", k, (nbits+dif)%d_framebits);
++- data[((nbits+dif)%d_framebits)] = k;
++-
++- retval = endstate;
++- }
++- nbits += 1;
++-
++- while(nbits-- != 0) {
++- int k;
++-
++- dec.t = &d[nbits * d_decision_t_size];
++-
++- k = (dec.w[(endstate>>d_ADDSHIFT)/32] >> ((endstate>>d_ADDSHIFT)%32)) & 1;
++-
++- endstate = (endstate >> 1) | (k << (d_k-2+d_ADDSHIFT));
++- data[((nbits+dif)%d_framebits)] = k;
++- }
++- //printf("%d, %d, %d, %d, %d, %d, %d, %d\n", data[4095],data[4094],data[4093],data[4092],data[4091],data[4090],data[4089],data[4088]);
++-
++-
++- return retval >> d_ADDSHIFT;
+++ unsigned char* d;
+++ int d_ADDSHIFT = 0;
+++ int d_numstates = (1 << 6);
+++ int d_decision_t_size = d_numstates / 8;
+++ unsigned int d_k = 7;
+++ int d_framebits = nbits;
+++ /* ADDSHIFT and SUBSHIFT make sure that the thing returned is a byte. */
+++ d = decisions;
+++ /* Make room beyond the end of the encoder register so we can
+++ * accumulate a full byte of decoded data
+++ */
+++
+++ endstate = (endstate % d_numstates) << d_ADDSHIFT;
+++
+++ /* The store into data[] only needs to be done every 8 bits.
+++ * But this avoids a conditional branch, and the writes will
+++ * combine in the cache anyway
+++ */
+++
+++ d += tailsize * d_decision_t_size; /* Look past tail */
+++ int retval;
+++ int dif = tailsize - (d_k - 1);
+++ // printf("break, %d, %d\n", dif, (nbits+dif)%d_framebits);
+++ p_decision_t dec;
+++ while (nbits-- > d_framebits - (d_k - 1)) {
+++ int k;
+++ dec.t = &d[nbits * d_decision_t_size];
+++ k = (dec.w[(endstate >> d_ADDSHIFT) / 32] >> ((endstate >> d_ADDSHIFT) % 32)) & 1;
+++
+++ endstate = (endstate >> 1) | (k << (d_k - 2 + d_ADDSHIFT));
+++ // data[((nbits+dif)%nbits)>>3] = endstate>>d_SUBSHIFT;
+++ // printf("%d, %d\n", k, (nbits+dif)%d_framebits);
+++ data[((nbits + dif) % d_framebits)] = k;
+++
+++ retval = endstate;
+++ }
+++ nbits += 1;
+++
+++ while (nbits-- != 0) {
+++ int k;
+++
+++ dec.t = &d[nbits * d_decision_t_size];
+++
+++ k = (dec.w[(endstate >> d_ADDSHIFT) / 32] >> ((endstate >> d_ADDSHIFT) % 32)) & 1;
+++
+++ endstate = (endstate >> 1) | (k << (d_k - 2 + d_ADDSHIFT));
+++ data[((nbits + dif) % d_framebits)] = k;
+++ }
+++ // printf("%d, %d, %d, %d, %d, %d, %d, %d\n",
+++ // data[4095],data[4094],data[4093],data[4092],data[4091],data[4090],data[4089],data[4088]);
+++
+++
+++ return retval >> d_ADDSHIFT;
++ }
++
++
++ #if LV_HAVE_SSE3
++
++-#include <pmmintrin.h>
++ #include <emmintrin.h>
++-#include <xmmintrin.h>
++ #include <mmintrin.h>
+++#include <pmmintrin.h>
++ #include <stdio.h>
+++#include <xmmintrin.h>
++
++-static inline void volk_8u_conv_k7_r2puppet_8u_spiral(unsigned char* syms, unsigned char* dec, unsigned int framebits) {
++-
++-
++- static int once = 1;
++- int d_numstates = (1 << 6);
++- int rate = 2;
++- static unsigned char* D;
++- static unsigned char* Y;
++- static unsigned char* X;
++- static unsigned int excess = 6;
++- static unsigned char* Branchtab;
++- static unsigned char Partab[256];
++-
++- int d_polys[2] = {79, 109};
++-
++-
++- if(once) {
++-
++- X = (unsigned char*)volk_malloc(2*d_numstates, volk_get_alignment());
++- Y = X + d_numstates;
++- Branchtab = (unsigned char*)volk_malloc(d_numstates/2*rate, volk_get_alignment());
++- D = (unsigned char*)volk_malloc((d_numstates/8) * (framebits + 6), volk_get_alignment());
++- int state, i;
++- int cnt,ti;
++-
++- /* Initialize parity lookup table */
++- for(i=0;i<256;i++){
++- cnt = 0;
++- ti = i;
++- while(ti){
++- if(ti & 1)
++- cnt++;
++- ti >>= 1;
++- }
++- Partab[i] = cnt & 1;
++- }
++- /* Initialize the branch table */
++- for(state=0;state < d_numstates/2;state++){
++- for(i=0; i<rate; i++){
++- Branchtab[i*d_numstates/2+state] = parity((2*state) & d_polys[i], Partab) ? 255 : 0;
++- }
++- }
+++static inline void volk_8u_conv_k7_r2puppet_8u_spiral(unsigned char* syms,
+++ unsigned char* dec,
+++ unsigned int framebits)
+++{
++
++- once = 0;
++- }
++
++- //unbias the old_metrics
++- memset(X, 31, d_numstates);
+++ static int once = 1;
+++ int d_numstates = (1 << 6);
+++ int rate = 2;
+++ static unsigned char* D;
+++ static unsigned char* Y;
+++ static unsigned char* X;
+++ static unsigned int excess = 6;
+++ static unsigned char* Branchtab;
+++ static unsigned char Partab[256];
+++
+++ int d_polys[2] = { 79, 109 };
+++
+++
+++ if (once) {
+++
+++ X = (unsigned char*)volk_malloc(2 * d_numstates, volk_get_alignment());
+++ Y = X + d_numstates;
+++ Branchtab =
+++ (unsigned char*)volk_malloc(d_numstates / 2 * rate, volk_get_alignment());
+++ D = (unsigned char*)volk_malloc((d_numstates / 8) * (framebits + 6),
+++ volk_get_alignment());
+++ int state, i;
+++ int cnt, ti;
+++
+++ /* Initialize parity lookup table */
+++ for (i = 0; i < 256; i++) {
+++ cnt = 0;
+++ ti = i;
+++ while (ti) {
+++ if (ti & 1)
+++ cnt++;
+++ ti >>= 1;
+++ }
+++ Partab[i] = cnt & 1;
+++ }
+++ /* Initialize the branch table */
+++ for (state = 0; state < d_numstates / 2; state++) {
+++ for (i = 0; i < rate; i++) {
+++ Branchtab[i * d_numstates / 2 + state] =
+++ parity((2 * state) & d_polys[i], Partab) ? 255 : 0;
+++ }
+++ }
+++
+++ once = 0;
+++ }
+++
+++ // unbias the old_metrics
+++ memset(X, 31, d_numstates);
++
++- // initialize decisions
++- memset(D, 0, (d_numstates/8) * (framebits + 6));
+++ // initialize decisions
+++ memset(D, 0, (d_numstates / 8) * (framebits + 6));
++
++- volk_8u_x4_conv_k7_r2_8u_spiral(Y, X, syms, D, framebits/2 - excess, excess, Branchtab);
+++ volk_8u_x4_conv_k7_r2_8u_spiral(
+++ Y, X, syms, D, framebits / 2 - excess, excess, Branchtab);
++
++- unsigned int min = X[0];
++- int i = 0, state = 0;
++- for(i = 0; i < (d_numstates); ++i) {
++- if(X[i] < min) {
++- min = X[i];
++- state = i;
+++ unsigned int min = X[0];
+++ int i = 0, state = 0;
+++ for (i = 0; i < (d_numstates); ++i) {
+++ if (X[i] < min) {
+++ min = X[i];
+++ state = i;
+++ }
++ }
++- }
++
++- chainback_viterbi(dec, framebits/2 -excess, state, excess, D);
+++ chainback_viterbi(dec, framebits / 2 - excess, state, excess, D);
++
++- return;
+++ return;
++ }
++
++ #endif /*LV_HAVE_SSE3*/
++@@ -185,151 +193,161 @@ static inline void volk_8u_conv_k7_r2puppet_8u_spiral(unsigned char* syms, unsig
++ #include <immintrin.h>
++ #include <stdio.h>
++
++-static inline void volk_8u_conv_k7_r2puppet_8u_avx2(unsigned char* syms, unsigned char* dec, unsigned int framebits) {
++-
++-
++- static int once = 1;
++- int d_numstates = (1 << 6);
++- int rate = 2;
++- static unsigned char* D;
++- static unsigned char* Y;
++- static unsigned char* X;
++- static unsigned int excess = 6;
++- static unsigned char* Branchtab;
++- static unsigned char Partab[256];
++-
++- int d_polys[2] = {79, 109};
++-
++-
++- if(once) {
++-
++- X = (unsigned char*)volk_malloc(2*d_numstates, volk_get_alignment());
++- Y = X + d_numstates;
++- Branchtab = (unsigned char*)volk_malloc(d_numstates/2*rate, volk_get_alignment());
++- D = (unsigned char*)volk_malloc((d_numstates/8) * (framebits + 6), volk_get_alignment());
++- int state, i;
++- int cnt,ti;
++-
++- /* Initialize parity lookup table */
++- for(i=0;i<256;i++){
++- cnt = 0;
++- ti = i;
++- while(ti){
++- if(ti & 1)
++- cnt++;
++- ti >>= 1;
++- }
++- Partab[i] = cnt & 1;
++- }
++- /* Initialize the branch table */
++- for(state=0;state < d_numstates/2;state++){
++- for(i=0; i<rate; i++){
++- Branchtab[i*d_numstates/2+state] = parity((2*state) & d_polys[i], Partab) ? 255 : 0;
++- }
++- }
+++static inline void volk_8u_conv_k7_r2puppet_8u_avx2(unsigned char* syms,
+++ unsigned char* dec,
+++ unsigned int framebits)
+++{
++
++- once = 0;
++- }
++
++- //unbias the old_metrics
++- memset(X, 31, d_numstates);
+++ static int once = 1;
+++ int d_numstates = (1 << 6);
+++ int rate = 2;
+++ static unsigned char* D;
+++ static unsigned char* Y;
+++ static unsigned char* X;
+++ static unsigned int excess = 6;
+++ static unsigned char* Branchtab;
+++ static unsigned char Partab[256];
+++
+++ int d_polys[2] = { 79, 109 };
+++
+++
+++ if (once) {
+++
+++ X = (unsigned char*)volk_malloc(2 * d_numstates, volk_get_alignment());
+++ Y = X + d_numstates;
+++ Branchtab =
+++ (unsigned char*)volk_malloc(d_numstates / 2 * rate, volk_get_alignment());
+++ D = (unsigned char*)volk_malloc((d_numstates / 8) * (framebits + 6),
+++ volk_get_alignment());
+++ int state, i;
+++ int cnt, ti;
+++
+++ /* Initialize parity lookup table */
+++ for (i = 0; i < 256; i++) {
+++ cnt = 0;
+++ ti = i;
+++ while (ti) {
+++ if (ti & 1)
+++ cnt++;
+++ ti >>= 1;
+++ }
+++ Partab[i] = cnt & 1;
+++ }
+++ /* Initialize the branch table */
+++ for (state = 0; state < d_numstates / 2; state++) {
+++ for (i = 0; i < rate; i++) {
+++ Branchtab[i * d_numstates / 2 + state] =
+++ parity((2 * state) & d_polys[i], Partab) ? 255 : 0;
+++ }
+++ }
+++
+++ once = 0;
+++ }
+++
+++ // unbias the old_metrics
+++ memset(X, 31, d_numstates);
++
++- // initialize decisions
++- memset(D, 0, (d_numstates/8) * (framebits + 6));
+++ // initialize decisions
+++ memset(D, 0, (d_numstates / 8) * (framebits + 6));
++
++- volk_8u_x4_conv_k7_r2_8u_avx2(Y, X, syms, D, framebits/2 - excess, excess, Branchtab);
+++ volk_8u_x4_conv_k7_r2_8u_avx2(
+++ Y, X, syms, D, framebits / 2 - excess, excess, Branchtab);
++
++- unsigned int min = X[0];
++- int i = 0, state = 0;
++- for(i = 0; i < (d_numstates); ++i) {
++- if(X[i] < min) {
++- min = X[i];
++- state = i;
+++ unsigned int min = X[0];
+++ int i = 0, state = 0;
+++ for (i = 0; i < (d_numstates); ++i) {
+++ if (X[i] < min) {
+++ min = X[i];
+++ state = i;
+++ }
++ }
++- }
++
++- chainback_viterbi(dec, framebits/2 -excess, state, excess, D);
+++ chainback_viterbi(dec, framebits / 2 - excess, state, excess, D);
++
++- return;
+++ return;
++ }
++
++ #endif /*LV_HAVE_AVX2*/
++
++
++-
++ #if LV_HAVE_GENERIC
++
++
++-static inline void volk_8u_conv_k7_r2puppet_8u_generic(unsigned char* syms, unsigned char* dec, unsigned int framebits) {
++-
++-
++-
++- static int once = 1;
++- int d_numstates = (1 << 6);
++- int rate = 2;
++- static unsigned char* Y;
++- static unsigned char* X;
++- static unsigned char* D;
++- static unsigned int excess = 6;
++- static unsigned char* Branchtab;
++- static unsigned char Partab[256];
++-
++- int d_polys[2] = {79, 109};
++-
++-
++- if(once) {
++-
++- X = (unsigned char*)volk_malloc(2*d_numstates, volk_get_alignment());
++- Y = X + d_numstates;
++- Branchtab = (unsigned char*)volk_malloc(d_numstates/2*rate, volk_get_alignment());
++- D = (unsigned char*)volk_malloc((d_numstates/8) * (framebits + 6), volk_get_alignment());
+++static inline void volk_8u_conv_k7_r2puppet_8u_generic(unsigned char* syms,
+++ unsigned char* dec,
+++ unsigned int framebits)
+++{
++
++- int state, i;
++- int cnt,ti;
++
++- /* Initialize parity lookup table */
++- for(i=0;i<256;i++){
++- cnt = 0;
++- ti = i;
++- while(ti){
++- if(ti & 1)
++- cnt++;
++- ti >>= 1;
++- }
++- Partab[i] = cnt & 1;
+++ static int once = 1;
+++ int d_numstates = (1 << 6);
+++ int rate = 2;
+++ static unsigned char* Y;
+++ static unsigned char* X;
+++ static unsigned char* D;
+++ static unsigned int excess = 6;
+++ static unsigned char* Branchtab;
+++ static unsigned char Partab[256];
+++
+++ int d_polys[2] = { 79, 109 };
+++
+++
+++ if (once) {
+++
+++ X = (unsigned char*)volk_malloc(2 * d_numstates, volk_get_alignment());
+++ Y = X + d_numstates;
+++ Branchtab =
+++ (unsigned char*)volk_malloc(d_numstates / 2 * rate, volk_get_alignment());
+++ D = (unsigned char*)volk_malloc((d_numstates / 8) * (framebits + 6),
+++ volk_get_alignment());
+++
+++ int state, i;
+++ int cnt, ti;
+++
+++ /* Initialize parity lookup table */
+++ for (i = 0; i < 256; i++) {
+++ cnt = 0;
+++ ti = i;
+++ while (ti) {
+++ if (ti & 1)
+++ cnt++;
+++ ti >>= 1;
+++ }
+++ Partab[i] = cnt & 1;
+++ }
+++ /* Initialize the branch table */
+++ for (state = 0; state < d_numstates / 2; state++) {
+++ for (i = 0; i < rate; i++) {
+++ Branchtab[i * d_numstates / 2 + state] =
+++ parity((2 * state) & d_polys[i], Partab) ? 255 : 0;
+++ }
+++ }
+++
+++ once = 0;
++ }
++- /* Initialize the branch table */
++- for(state=0;state < d_numstates/2;state++){
++- for(i=0; i<rate; i++){
++- Branchtab[i*d_numstates/2+state] = parity((2*state) & d_polys[i], Partab) ? 255 : 0;
++- }
++- }
++-
++- once = 0;
++- }
++
++- //unbias the old_metrics
++- memset(X, 31, d_numstates);
+++ // unbias the old_metrics
+++ memset(X, 31, d_numstates);
++
++- // initialize decisions
++- memset(D, 0, (d_numstates/8) * (framebits + 6));
+++ // initialize decisions
+++ memset(D, 0, (d_numstates / 8) * (framebits + 6));
++
++- volk_8u_x4_conv_k7_r2_8u_generic(Y, X, syms, D, framebits/2 - excess, excess, Branchtab);
+++ volk_8u_x4_conv_k7_r2_8u_generic(
+++ Y, X, syms, D, framebits / 2 - excess, excess, Branchtab);
++
++- unsigned int min = X[0];
++- int i = 0, state = 0;
++- for(i = 0; i < (d_numstates); ++i) {
++- if(X[i] < min) {
++- min = X[i];
++- state = i;
+++ unsigned int min = X[0];
+++ int i = 0, state = 0;
+++ for (i = 0; i < (d_numstates); ++i) {
+++ if (X[i] < min) {
+++ min = X[i];
+++ state = i;
+++ }
++ }
++- }
++-
++- chainback_viterbi(dec, framebits/2 -excess, state, excess, D);
++-
++- return;
++
+++ chainback_viterbi(dec, framebits / 2 - excess, state, excess, D);
++
+++ return;
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++diff --git a/kernels/volk/volk_8u_x2_encodeframepolar_8u.h b/kernels/volk/volk_8u_x2_encodeframepolar_8u.h
++index bc176ec..e8d980d 100644
++--- a/kernels/volk/volk_8u_x2_encodeframepolar_8u.h
+++++ b/kernels/volk/volk_8u_x2_encodeframepolar_8u.h
++@@ -28,172 +28,236 @@
++ #define VOLK_KERNELS_VOLK_VOLK_8U_X2_ENCODEFRAMEPOLAR_8U_U_H_
++ #include <string.h>
++
++-static inline unsigned int
++-log2_of_power_of_2(unsigned int val){
++- // algorithm from: http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog
++- static const unsigned int b[] = {0xAAAAAAAA, 0xCCCCCCCC, 0xF0F0F0F0,
++- 0xFF00FF00, 0xFFFF0000};
++-
++- unsigned int res = (val & b[0]) != 0;
++- res |= ((val & b[4]) != 0) << 4;
++- res |= ((val & b[3]) != 0) << 3;
++- res |= ((val & b[2]) != 0) << 2;
++- res |= ((val & b[1]) != 0) << 1;
++- return res;
+++static inline unsigned int log2_of_power_of_2(unsigned int val)
+++{
+++ // algorithm from: http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog
+++ static const unsigned int b[] = {
+++ 0xAAAAAAAA, 0xCCCCCCCC, 0xF0F0F0F0, 0xFF00FF00, 0xFFFF0000
+++ };
+++
+++ unsigned int res = (val & b[0]) != 0;
+++ res |= ((val & b[4]) != 0) << 4;
+++ res |= ((val & b[3]) != 0) << 3;
+++ res |= ((val & b[2]) != 0) << 2;
+++ res |= ((val & b[1]) != 0) << 1;
+++ return res;
++ }
++
++-static inline void
++-encodepolar_single_stage(unsigned char* frame_ptr, const unsigned char* temp_ptr,
++- const unsigned int num_branches, const unsigned int frame_half)
+++static inline void encodepolar_single_stage(unsigned char* frame_ptr,
+++ const unsigned char* temp_ptr,
+++ const unsigned int num_branches,
+++ const unsigned int frame_half)
++ {
++- unsigned int branch, bit;
++- for(branch = 0; branch < num_branches; ++branch){
++- for(bit = 0; bit < frame_half; ++bit){
++- *frame_ptr = *temp_ptr ^ *(temp_ptr + 1);
++- *(frame_ptr + frame_half) = *(temp_ptr + 1);
++- ++frame_ptr;
++- temp_ptr += 2;
+++ unsigned int branch, bit;
+++ for (branch = 0; branch < num_branches; ++branch) {
+++ for (bit = 0; bit < frame_half; ++bit) {
+++ *frame_ptr = *temp_ptr ^ *(temp_ptr + 1);
+++ *(frame_ptr + frame_half) = *(temp_ptr + 1);
+++ ++frame_ptr;
+++ temp_ptr += 2;
+++ }
+++ frame_ptr += frame_half;
++ }
++- frame_ptr += frame_half;
++- }
++ }
++
++ #ifdef LV_HAVE_GENERIC
++
++-static inline void
++-volk_8u_x2_encodeframepolar_8u_generic(unsigned char* frame, unsigned char* temp,
++- unsigned int frame_size)
+++static inline void volk_8u_x2_encodeframepolar_8u_generic(unsigned char* frame,
+++ unsigned char* temp,
+++ unsigned int frame_size)
++ {
++- unsigned int stage = log2_of_power_of_2(frame_size);
++- unsigned int frame_half = frame_size >> 1;
++- unsigned int num_branches = 1;
++-
++- while(stage){
++- // encode stage
++- encodepolar_single_stage(frame, temp, num_branches, frame_half);
++- memcpy(temp, frame, sizeof(unsigned char) * frame_size);
++-
++- // update all the parameters.
++- num_branches = num_branches << 1;
++- frame_half = frame_half >> 1;
++- --stage;
++- }
+++ unsigned int stage = log2_of_power_of_2(frame_size);
+++ unsigned int frame_half = frame_size >> 1;
+++ unsigned int num_branches = 1;
+++
+++ while (stage) {
+++ // encode stage
+++ encodepolar_single_stage(frame, temp, num_branches, frame_half);
+++ memcpy(temp, frame, sizeof(unsigned char) * frame_size);
+++
+++ // update all the parameters.
+++ num_branches = num_branches << 1;
+++ frame_half = frame_half >> 1;
+++ --stage;
+++ }
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++ #ifdef LV_HAVE_SSSE3
++ #include <tmmintrin.h>
++
++-static inline void
++-volk_8u_x2_encodeframepolar_8u_u_ssse3(unsigned char* frame, unsigned char* temp,
++- unsigned int frame_size)
+++static inline void volk_8u_x2_encodeframepolar_8u_u_ssse3(unsigned char* frame,
+++ unsigned char* temp,
+++ unsigned int frame_size)
++ {
++- const unsigned int po2 = log2_of_power_of_2(frame_size);
++-
++- unsigned int stage = po2;
++- unsigned char* frame_ptr = frame;
++- unsigned char* temp_ptr = temp;
++-
++- unsigned int frame_half = frame_size >> 1;
++- unsigned int num_branches = 1;
++- unsigned int branch;
++- unsigned int bit;
++-
++- // prepare constants
++- const __m128i mask_stage1 = _mm_set_epi8(0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF);
++-
++- // get some SIMD registers to play with.
++- __m128i r_frame0, r_temp0, shifted;
++-
++- {
++- __m128i r_frame1, r_temp1;
++- const __m128i shuffle_separate = _mm_setr_epi8(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15);
++-
++- while(stage > 4){
++- frame_ptr = frame;
++- temp_ptr = temp;
++-
++- // for stage = 5 a branch has 32 elements. So upper stages are even bigger.
++- for(branch = 0; branch < num_branches; ++branch){
++- for(bit = 0; bit < frame_half; bit += 16){
++- r_temp0 = _mm_loadu_si128((__m128i *) temp_ptr);
++- temp_ptr += 16;
++- r_temp1 = _mm_loadu_si128((__m128i *) temp_ptr);
++- temp_ptr += 16;
++-
++- shifted = _mm_srli_si128(r_temp0, 1);
++- shifted = _mm_and_si128(shifted, mask_stage1);
++- r_temp0 = _mm_xor_si128(shifted, r_temp0);
++- r_temp0 = _mm_shuffle_epi8(r_temp0, shuffle_separate);
++-
++- shifted = _mm_srli_si128(r_temp1, 1);
++- shifted = _mm_and_si128(shifted, mask_stage1);
++- r_temp1 = _mm_xor_si128(shifted, r_temp1);
++- r_temp1 = _mm_shuffle_epi8(r_temp1, shuffle_separate);
++-
++- r_frame0 = _mm_unpacklo_epi64(r_temp0, r_temp1);
++- _mm_storeu_si128((__m128i*) frame_ptr, r_frame0);
++-
++- r_frame1 = _mm_unpackhi_epi64(r_temp0, r_temp1);
++- _mm_storeu_si128((__m128i*) (frame_ptr + frame_half), r_frame1);
++- frame_ptr += 16;
+++ const unsigned int po2 = log2_of_power_of_2(frame_size);
+++
+++ unsigned int stage = po2;
+++ unsigned char* frame_ptr = frame;
+++ unsigned char* temp_ptr = temp;
+++
+++ unsigned int frame_half = frame_size >> 1;
+++ unsigned int num_branches = 1;
+++ unsigned int branch;
+++ unsigned int bit;
+++
+++ // prepare constants
+++ const __m128i mask_stage1 = _mm_set_epi8(0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF);
+++
+++ // get some SIMD registers to play with.
+++ __m128i r_frame0, r_temp0, shifted;
+++
+++ {
+++ __m128i r_frame1, r_temp1;
+++ const __m128i shuffle_separate =
+++ _mm_setr_epi8(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15);
+++
+++ while (stage > 4) {
+++ frame_ptr = frame;
+++ temp_ptr = temp;
+++
+++ // for stage = 5 a branch has 32 elements. So upper stages are even bigger.
+++ for (branch = 0; branch < num_branches; ++branch) {
+++ for (bit = 0; bit < frame_half; bit += 16) {
+++ r_temp0 = _mm_loadu_si128((__m128i*)temp_ptr);
+++ temp_ptr += 16;
+++ r_temp1 = _mm_loadu_si128((__m128i*)temp_ptr);
+++ temp_ptr += 16;
+++
+++ shifted = _mm_srli_si128(r_temp0, 1);
+++ shifted = _mm_and_si128(shifted, mask_stage1);
+++ r_temp0 = _mm_xor_si128(shifted, r_temp0);
+++ r_temp0 = _mm_shuffle_epi8(r_temp0, shuffle_separate);
+++
+++ shifted = _mm_srli_si128(r_temp1, 1);
+++ shifted = _mm_and_si128(shifted, mask_stage1);
+++ r_temp1 = _mm_xor_si128(shifted, r_temp1);
+++ r_temp1 = _mm_shuffle_epi8(r_temp1, shuffle_separate);
+++
+++ r_frame0 = _mm_unpacklo_epi64(r_temp0, r_temp1);
+++ _mm_storeu_si128((__m128i*)frame_ptr, r_frame0);
+++
+++ r_frame1 = _mm_unpackhi_epi64(r_temp0, r_temp1);
+++ _mm_storeu_si128((__m128i*)(frame_ptr + frame_half), r_frame1);
+++ frame_ptr += 16;
+++ }
+++
+++ frame_ptr += frame_half;
+++ }
+++ memcpy(temp, frame, sizeof(unsigned char) * frame_size);
+++
+++ num_branches = num_branches << 1;
+++ frame_half = frame_half >> 1;
+++ stage--;
++ }
++-
++- frame_ptr += frame_half;
++- }
++- memcpy(temp, frame, sizeof(unsigned char) * frame_size);
++-
++- num_branches = num_branches << 1;
++- frame_half = frame_half >> 1;
++- stage--;
++ }
++- }
++
++- // This last part requires at least 16-bit frames.
++- // Smaller frames are useless for SIMD optimization anyways. Just choose GENERIC!
+++ // This last part requires at least 16-bit frames.
+++ // Smaller frames are useless for SIMD optimization anyways. Just choose GENERIC!
++
++- // reset pointers to correct positions.
++- frame_ptr = frame;
++- temp_ptr = temp;
+++ // reset pointers to correct positions.
+++ frame_ptr = frame;
+++ temp_ptr = temp;
++
++- // prefetch first chunk
++- __VOLK_PREFETCH(temp_ptr);
++-
++- const __m128i shuffle_stage4 = _mm_setr_epi8(0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15);
++- const __m128i mask_stage4 = _mm_set_epi8(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
++- const __m128i mask_stage3 = _mm_set_epi8(0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF);
++- const __m128i mask_stage2 = _mm_set_epi8(0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF);
++-
++- for(branch = 0; branch < num_branches; ++branch){
++- r_temp0 = _mm_loadu_si128((__m128i*) temp_ptr);
++-
++- // prefetch next chunk
++- temp_ptr += 16;
+++ // prefetch first chunk
++ __VOLK_PREFETCH(temp_ptr);
++
++- // shuffle once for bit-reversal.
++- r_temp0 = _mm_shuffle_epi8(r_temp0, shuffle_stage4);
++-
++- shifted = _mm_srli_si128(r_temp0, 8);
++- shifted = _mm_and_si128(shifted, mask_stage4);
++- r_frame0 = _mm_xor_si128(shifted, r_temp0);
++-
++- shifted = _mm_srli_si128(r_frame0, 4);
++- shifted = _mm_and_si128(shifted, mask_stage3);
++- r_frame0 = _mm_xor_si128(shifted, r_frame0);
++-
++- shifted = _mm_srli_si128(r_frame0, 2);
++- shifted = _mm_and_si128(shifted, mask_stage2);
++- r_frame0 = _mm_xor_si128(shifted, r_frame0);
++-
++- shifted = _mm_srli_si128(r_frame0, 1);
++- shifted = _mm_and_si128(shifted, mask_stage1);
++- r_frame0 = _mm_xor_si128(shifted, r_frame0);
++-
++- // store result of chunk.
++- _mm_storeu_si128((__m128i*)frame_ptr, r_frame0);
++- frame_ptr += 16;
++- }
+++ const __m128i shuffle_stage4 =
+++ _mm_setr_epi8(0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15);
+++ const __m128i mask_stage4 = _mm_set_epi8(0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF);
+++ const __m128i mask_stage3 = _mm_set_epi8(0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF);
+++ const __m128i mask_stage2 = _mm_set_epi8(0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF);
+++
+++ for (branch = 0; branch < num_branches; ++branch) {
+++ r_temp0 = _mm_loadu_si128((__m128i*)temp_ptr);
+++
+++ // prefetch next chunk
+++ temp_ptr += 16;
+++ __VOLK_PREFETCH(temp_ptr);
+++
+++ // shuffle once for bit-reversal.
+++ r_temp0 = _mm_shuffle_epi8(r_temp0, shuffle_stage4);
+++
+++ shifted = _mm_srli_si128(r_temp0, 8);
+++ shifted = _mm_and_si128(shifted, mask_stage4);
+++ r_frame0 = _mm_xor_si128(shifted, r_temp0);
+++
+++ shifted = _mm_srli_si128(r_frame0, 4);
+++ shifted = _mm_and_si128(shifted, mask_stage3);
+++ r_frame0 = _mm_xor_si128(shifted, r_frame0);
+++
+++ shifted = _mm_srli_si128(r_frame0, 2);
+++ shifted = _mm_and_si128(shifted, mask_stage2);
+++ r_frame0 = _mm_xor_si128(shifted, r_frame0);
+++
+++ shifted = _mm_srli_si128(r_frame0, 1);
+++ shifted = _mm_and_si128(shifted, mask_stage1);
+++ r_frame0 = _mm_xor_si128(shifted, r_frame0);
+++
+++ // store result of chunk.
+++ _mm_storeu_si128((__m128i*)frame_ptr, r_frame0);
+++ frame_ptr += 16;
+++ }
++ }
++
++ #endif /* LV_HAVE_SSSE3 */
++@@ -201,154 +265,351 @@ volk_8u_x2_encodeframepolar_8u_u_ssse3(unsigned char* frame, unsigned char* temp
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8u_x2_encodeframepolar_8u_u_avx2(unsigned char* frame, unsigned char* temp,
++- unsigned int frame_size)
+++static inline void volk_8u_x2_encodeframepolar_8u_u_avx2(unsigned char* frame,
+++ unsigned char* temp,
+++ unsigned int frame_size)
++ {
++- const unsigned int po2 = log2_of_power_of_2(frame_size);
++-
++- unsigned int stage = po2;
++- unsigned char* frame_ptr = frame;
++- unsigned char* temp_ptr = temp;
++-
++- unsigned int frame_half = frame_size >> 1;
++- unsigned int num_branches = 1;
++- unsigned int branch;
++- unsigned int bit;
++-
++- // prepare constants
++- const __m256i mask_stage1 = _mm256_set_epi8(0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF,
++- 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF);
++-
++- const __m128i mask_stage0 = _mm_set_epi8(0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF);
++- // get some SIMD registers to play with.
++- __m256i r_frame0, r_temp0, shifted;
++- __m128i r_temp2, r_frame2, shifted2;
++- {
++- __m256i r_frame1, r_temp1;
++- __m128i r_frame3, r_temp3;
++- const __m256i shuffle_separate = _mm256_setr_epi8(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15,
++- 0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15);
++- const __m128i shuffle_separate128 = _mm_setr_epi8(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15);
++-
++- while(stage > 4){
++- frame_ptr = frame;
++- temp_ptr = temp;
++-
++- // for stage = 5 a branch has 32 elements. So upper stages are even bigger.
++- for(branch = 0; branch < num_branches; ++branch){
++- for(bit = 0; bit < frame_half; bit += 32){
++- if ((frame_half-bit)<32) //if only 16 bits remaining in frame, not 32
++- {
++- r_temp2 = _mm_loadu_si128((__m128i *) temp_ptr);
++- temp_ptr += 16;
++- r_temp3 = _mm_loadu_si128((__m128i *) temp_ptr);
++- temp_ptr += 16;
++-
++- shifted2 = _mm_srli_si128(r_temp2, 1);
++- shifted2 = _mm_and_si128(shifted2, mask_stage0);
++- r_temp2 = _mm_xor_si128(shifted2, r_temp2);
++- r_temp2 = _mm_shuffle_epi8(r_temp2, shuffle_separate128);
++-
++- shifted2 = _mm_srli_si128(r_temp3, 1);
++- shifted2 = _mm_and_si128(shifted2, mask_stage0);
++- r_temp3 = _mm_xor_si128(shifted2, r_temp3);
++- r_temp3 = _mm_shuffle_epi8(r_temp3, shuffle_separate128);
++-
++- r_frame2 = _mm_unpacklo_epi64(r_temp2, r_temp3);
++- _mm_storeu_si128((__m128i*) frame_ptr, r_frame2);
++-
++- r_frame3 = _mm_unpackhi_epi64(r_temp2, r_temp3);
++- _mm_storeu_si128((__m128i*) (frame_ptr + frame_half), r_frame3);
++- frame_ptr += 16;
++- break;
++- }
++- r_temp0 = _mm256_loadu_si256((__m256i *) temp_ptr);
++- temp_ptr += 32;
++- r_temp1 = _mm256_loadu_si256((__m256i *) temp_ptr);
++- temp_ptr += 32;
++-
++- shifted = _mm256_srli_si256(r_temp0, 1);//operate on 128 bit lanes
++- shifted = _mm256_and_si256(shifted, mask_stage1);
++- r_temp0 = _mm256_xor_si256(shifted, r_temp0);
++- r_temp0 = _mm256_shuffle_epi8(r_temp0, shuffle_separate);
++-
++- shifted = _mm256_srli_si256(r_temp1, 1);
++- shifted = _mm256_and_si256(shifted, mask_stage1);
++- r_temp1 = _mm256_xor_si256(shifted, r_temp1);
++- r_temp1 = _mm256_shuffle_epi8(r_temp1, shuffle_separate);
++-
++- r_frame0 = _mm256_unpacklo_epi64(r_temp0, r_temp1);
++- r_temp1 = _mm256_unpackhi_epi64(r_temp0, r_temp1);
++- r_frame0 = _mm256_permute4x64_epi64(r_frame0, 0xd8);
++- r_frame1 = _mm256_permute4x64_epi64(r_temp1, 0xd8);
++-
++- _mm256_storeu_si256((__m256i*) frame_ptr, r_frame0);
++-
++- _mm256_storeu_si256((__m256i*) (frame_ptr + frame_half), r_frame1);
++- frame_ptr += 32;
+++ const unsigned int po2 = log2_of_power_of_2(frame_size);
+++
+++ unsigned int stage = po2;
+++ unsigned char* frame_ptr = frame;
+++ unsigned char* temp_ptr = temp;
+++
+++ unsigned int frame_half = frame_size >> 1;
+++ unsigned int num_branches = 1;
+++ unsigned int branch;
+++ unsigned int bit;
+++
+++ // prepare constants
+++ const __m256i mask_stage1 = _mm256_set_epi8(0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF);
+++
+++ const __m128i mask_stage0 = _mm_set_epi8(0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF);
+++ // get some SIMD registers to play with.
+++ __m256i r_frame0, r_temp0, shifted;
+++ __m128i r_temp2, r_frame2, shifted2;
+++ {
+++ __m256i r_frame1, r_temp1;
+++ __m128i r_frame3, r_temp3;
+++ const __m256i shuffle_separate = _mm256_setr_epi8(0,
+++ 2,
+++ 4,
+++ 6,
+++ 8,
+++ 10,
+++ 12,
+++ 14,
+++ 1,
+++ 3,
+++ 5,
+++ 7,
+++ 9,
+++ 11,
+++ 13,
+++ 15,
+++ 0,
+++ 2,
+++ 4,
+++ 6,
+++ 8,
+++ 10,
+++ 12,
+++ 14,
+++ 1,
+++ 3,
+++ 5,
+++ 7,
+++ 9,
+++ 11,
+++ 13,
+++ 15);
+++ const __m128i shuffle_separate128 =
+++ _mm_setr_epi8(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15);
+++
+++ while (stage > 4) {
+++ frame_ptr = frame;
+++ temp_ptr = temp;
+++
+++ // for stage = 5 a branch has 32 elements. So upper stages are even bigger.
+++ for (branch = 0; branch < num_branches; ++branch) {
+++ for (bit = 0; bit < frame_half; bit += 32) {
+++ if ((frame_half - bit) <
+++ 32) // if only 16 bits remaining in frame, not 32
+++ {
+++ r_temp2 = _mm_loadu_si128((__m128i*)temp_ptr);
+++ temp_ptr += 16;
+++ r_temp3 = _mm_loadu_si128((__m128i*)temp_ptr);
+++ temp_ptr += 16;
+++
+++ shifted2 = _mm_srli_si128(r_temp2, 1);
+++ shifted2 = _mm_and_si128(shifted2, mask_stage0);
+++ r_temp2 = _mm_xor_si128(shifted2, r_temp2);
+++ r_temp2 = _mm_shuffle_epi8(r_temp2, shuffle_separate128);
+++
+++ shifted2 = _mm_srli_si128(r_temp3, 1);
+++ shifted2 = _mm_and_si128(shifted2, mask_stage0);
+++ r_temp3 = _mm_xor_si128(shifted2, r_temp3);
+++ r_temp3 = _mm_shuffle_epi8(r_temp3, shuffle_separate128);
+++
+++ r_frame2 = _mm_unpacklo_epi64(r_temp2, r_temp3);
+++ _mm_storeu_si128((__m128i*)frame_ptr, r_frame2);
+++
+++ r_frame3 = _mm_unpackhi_epi64(r_temp2, r_temp3);
+++ _mm_storeu_si128((__m128i*)(frame_ptr + frame_half), r_frame3);
+++ frame_ptr += 16;
+++ break;
+++ }
+++ r_temp0 = _mm256_loadu_si256((__m256i*)temp_ptr);
+++ temp_ptr += 32;
+++ r_temp1 = _mm256_loadu_si256((__m256i*)temp_ptr);
+++ temp_ptr += 32;
+++
+++ shifted = _mm256_srli_si256(r_temp0, 1); // operate on 128 bit lanes
+++ shifted = _mm256_and_si256(shifted, mask_stage1);
+++ r_temp0 = _mm256_xor_si256(shifted, r_temp0);
+++ r_temp0 = _mm256_shuffle_epi8(r_temp0, shuffle_separate);
+++
+++ shifted = _mm256_srli_si256(r_temp1, 1);
+++ shifted = _mm256_and_si256(shifted, mask_stage1);
+++ r_temp1 = _mm256_xor_si256(shifted, r_temp1);
+++ r_temp1 = _mm256_shuffle_epi8(r_temp1, shuffle_separate);
+++
+++ r_frame0 = _mm256_unpacklo_epi64(r_temp0, r_temp1);
+++ r_temp1 = _mm256_unpackhi_epi64(r_temp0, r_temp1);
+++ r_frame0 = _mm256_permute4x64_epi64(r_frame0, 0xd8);
+++ r_frame1 = _mm256_permute4x64_epi64(r_temp1, 0xd8);
+++
+++ _mm256_storeu_si256((__m256i*)frame_ptr, r_frame0);
+++
+++ _mm256_storeu_si256((__m256i*)(frame_ptr + frame_half), r_frame1);
+++ frame_ptr += 32;
+++ }
+++
+++ frame_ptr += frame_half;
+++ }
+++ memcpy(temp, frame, sizeof(unsigned char) * frame_size);
+++
+++ num_branches = num_branches << 1;
+++ frame_half = frame_half >> 1;
+++ stage--;
++ }
++-
++- frame_ptr += frame_half;
++- }
++- memcpy(temp, frame, sizeof(unsigned char) * frame_size);
++-
++- num_branches = num_branches << 1;
++- frame_half = frame_half >> 1;
++- stage--;
++ }
++- }
++-
++- // This last part requires at least 32-bit frames.
++- // Smaller frames are useless for SIMD optimization anyways. Just choose GENERIC!
++-
++- // reset pointers to correct positions.
++- frame_ptr = frame;
++- temp_ptr = temp;
++
++- // prefetch first chunk
++- __VOLK_PREFETCH(temp_ptr);
+++ // This last part requires at least 32-bit frames.
+++ // Smaller frames are useless for SIMD optimization anyways. Just choose GENERIC!
++
++- const __m256i shuffle_stage4 = _mm256_setr_epi8(0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15,
++- 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15);
++- const __m256i mask_stage4 = _mm256_set_epi8(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
++- 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
++- const __m256i mask_stage3 = _mm256_set_epi8(0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF,
++- 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF);
++- const __m256i mask_stage2 = _mm256_set_epi8(0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF,
++- 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF);
+++ // reset pointers to correct positions.
+++ frame_ptr = frame;
+++ temp_ptr = temp;
++
++- for(branch = 0; branch < num_branches/2; ++branch){
++- r_temp0 = _mm256_loadu_si256((__m256i*) temp_ptr);
++-
++- // prefetch next chunk
++- temp_ptr += 32;
+++ // prefetch first chunk
++ __VOLK_PREFETCH(temp_ptr);
++
++- // shuffle once for bit-reversal.
++- r_temp0 = _mm256_shuffle_epi8(r_temp0, shuffle_stage4);
++-
++- shifted = _mm256_srli_si256(r_temp0, 8); //128 bit lanes
++- shifted = _mm256_and_si256(shifted, mask_stage4);
++- r_frame0 = _mm256_xor_si256(shifted, r_temp0);
++-
++-
++- shifted = _mm256_srli_si256(r_frame0, 4);
++- shifted = _mm256_and_si256(shifted, mask_stage3);
++- r_frame0 = _mm256_xor_si256(shifted, r_frame0);
++-
++- shifted = _mm256_srli_si256(r_frame0, 2);
++- shifted = _mm256_and_si256(shifted, mask_stage2);
++- r_frame0 = _mm256_xor_si256(shifted, r_frame0);
++-
++- shifted = _mm256_srli_si256(r_frame0, 1);
++- shifted = _mm256_and_si256(shifted, mask_stage1);
++- r_frame0 = _mm256_xor_si256(shifted, r_frame0);
++-
++- // store result of chunk.
++- _mm256_storeu_si256((__m256i*)frame_ptr, r_frame0);
++- frame_ptr += 32;
++- }
+++ const __m256i shuffle_stage4 = _mm256_setr_epi8(0,
+++ 8,
+++ 4,
+++ 12,
+++ 2,
+++ 10,
+++ 6,
+++ 14,
+++ 1,
+++ 9,
+++ 5,
+++ 13,
+++ 3,
+++ 11,
+++ 7,
+++ 15,
+++ 0,
+++ 8,
+++ 4,
+++ 12,
+++ 2,
+++ 10,
+++ 6,
+++ 14,
+++ 1,
+++ 9,
+++ 5,
+++ 13,
+++ 3,
+++ 11,
+++ 7,
+++ 15);
+++ const __m256i mask_stage4 = _mm256_set_epi8(0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF);
+++ const __m256i mask_stage3 = _mm256_set_epi8(0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF);
+++ const __m256i mask_stage2 = _mm256_set_epi8(0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF);
+++
+++ for (branch = 0; branch < num_branches / 2; ++branch) {
+++ r_temp0 = _mm256_loadu_si256((__m256i*)temp_ptr);
+++
+++ // prefetch next chunk
+++ temp_ptr += 32;
+++ __VOLK_PREFETCH(temp_ptr);
+++
+++ // shuffle once for bit-reversal.
+++ r_temp0 = _mm256_shuffle_epi8(r_temp0, shuffle_stage4);
+++
+++ shifted = _mm256_srli_si256(r_temp0, 8); // 128 bit lanes
+++ shifted = _mm256_and_si256(shifted, mask_stage4);
+++ r_frame0 = _mm256_xor_si256(shifted, r_temp0);
+++
+++
+++ shifted = _mm256_srli_si256(r_frame0, 4);
+++ shifted = _mm256_and_si256(shifted, mask_stage3);
+++ r_frame0 = _mm256_xor_si256(shifted, r_frame0);
+++
+++ shifted = _mm256_srli_si256(r_frame0, 2);
+++ shifted = _mm256_and_si256(shifted, mask_stage2);
+++ r_frame0 = _mm256_xor_si256(shifted, r_frame0);
+++
+++ shifted = _mm256_srli_si256(r_frame0, 1);
+++ shifted = _mm256_and_si256(shifted, mask_stage1);
+++ r_frame0 = _mm256_xor_si256(shifted, r_frame0);
+++
+++ // store result of chunk.
+++ _mm256_storeu_si256((__m256i*)frame_ptr, r_frame0);
+++ frame_ptr += 32;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -360,272 +621,530 @@ volk_8u_x2_encodeframepolar_8u_u_avx2(unsigned char* frame, unsigned char* temp,
++ #ifdef LV_HAVE_SSSE3
++ #include <tmmintrin.h>
++
++-static inline void
++-volk_8u_x2_encodeframepolar_8u_a_ssse3(unsigned char* frame, unsigned char* temp,
++- unsigned int frame_size)
+++static inline void volk_8u_x2_encodeframepolar_8u_a_ssse3(unsigned char* frame,
+++ unsigned char* temp,
+++ unsigned int frame_size)
++ {
++- const unsigned int po2 = log2_of_power_of_2(frame_size);
++-
++- unsigned int stage = po2;
++- unsigned char* frame_ptr = frame;
++- unsigned char* temp_ptr = temp;
++-
++- unsigned int frame_half = frame_size >> 1;
++- unsigned int num_branches = 1;
++- unsigned int branch;
++- unsigned int bit;
++-
++- // prepare constants
++- const __m128i mask_stage1 = _mm_set_epi8(0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF);
++-
++- // get some SIMD registers to play with.
++- __m128i r_frame0, r_temp0, shifted;
++-
++- {
++- __m128i r_frame1, r_temp1;
++- const __m128i shuffle_separate = _mm_setr_epi8(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15);
++-
++- while(stage > 4){
++- frame_ptr = frame;
++- temp_ptr = temp;
++-
++- // for stage = 5 a branch has 32 elements. So upper stages are even bigger.
++- for(branch = 0; branch < num_branches; ++branch){
++- for(bit = 0; bit < frame_half; bit += 16){
++- r_temp0 = _mm_load_si128((__m128i *) temp_ptr);
++- temp_ptr += 16;
++- r_temp1 = _mm_load_si128((__m128i *) temp_ptr);
++- temp_ptr += 16;
++-
++- shifted = _mm_srli_si128(r_temp0, 1);
++- shifted = _mm_and_si128(shifted, mask_stage1);
++- r_temp0 = _mm_xor_si128(shifted, r_temp0);
++- r_temp0 = _mm_shuffle_epi8(r_temp0, shuffle_separate);
++-
++- shifted = _mm_srli_si128(r_temp1, 1);
++- shifted = _mm_and_si128(shifted, mask_stage1);
++- r_temp1 = _mm_xor_si128(shifted, r_temp1);
++- r_temp1 = _mm_shuffle_epi8(r_temp1, shuffle_separate);
++-
++- r_frame0 = _mm_unpacklo_epi64(r_temp0, r_temp1);
++- _mm_store_si128((__m128i*) frame_ptr, r_frame0);
++-
++- r_frame1 = _mm_unpackhi_epi64(r_temp0, r_temp1);
++- _mm_store_si128((__m128i*) (frame_ptr + frame_half), r_frame1);
++- frame_ptr += 16;
+++ const unsigned int po2 = log2_of_power_of_2(frame_size);
+++
+++ unsigned int stage = po2;
+++ unsigned char* frame_ptr = frame;
+++ unsigned char* temp_ptr = temp;
+++
+++ unsigned int frame_half = frame_size >> 1;
+++ unsigned int num_branches = 1;
+++ unsigned int branch;
+++ unsigned int bit;
+++
+++ // prepare constants
+++ const __m128i mask_stage1 = _mm_set_epi8(0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF);
+++
+++ // get some SIMD registers to play with.
+++ __m128i r_frame0, r_temp0, shifted;
+++
+++ {
+++ __m128i r_frame1, r_temp1;
+++ const __m128i shuffle_separate =
+++ _mm_setr_epi8(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15);
+++
+++ while (stage > 4) {
+++ frame_ptr = frame;
+++ temp_ptr = temp;
+++
+++ // for stage = 5 a branch has 32 elements. So upper stages are even bigger.
+++ for (branch = 0; branch < num_branches; ++branch) {
+++ for (bit = 0; bit < frame_half; bit += 16) {
+++ r_temp0 = _mm_load_si128((__m128i*)temp_ptr);
+++ temp_ptr += 16;
+++ r_temp1 = _mm_load_si128((__m128i*)temp_ptr);
+++ temp_ptr += 16;
+++
+++ shifted = _mm_srli_si128(r_temp0, 1);
+++ shifted = _mm_and_si128(shifted, mask_stage1);
+++ r_temp0 = _mm_xor_si128(shifted, r_temp0);
+++ r_temp0 = _mm_shuffle_epi8(r_temp0, shuffle_separate);
+++
+++ shifted = _mm_srli_si128(r_temp1, 1);
+++ shifted = _mm_and_si128(shifted, mask_stage1);
+++ r_temp1 = _mm_xor_si128(shifted, r_temp1);
+++ r_temp1 = _mm_shuffle_epi8(r_temp1, shuffle_separate);
+++
+++ r_frame0 = _mm_unpacklo_epi64(r_temp0, r_temp1);
+++ _mm_store_si128((__m128i*)frame_ptr, r_frame0);
+++
+++ r_frame1 = _mm_unpackhi_epi64(r_temp0, r_temp1);
+++ _mm_store_si128((__m128i*)(frame_ptr + frame_half), r_frame1);
+++ frame_ptr += 16;
+++ }
+++
+++ frame_ptr += frame_half;
+++ }
+++ memcpy(temp, frame, sizeof(unsigned char) * frame_size);
+++
+++ num_branches = num_branches << 1;
+++ frame_half = frame_half >> 1;
+++ stage--;
++ }
++-
++- frame_ptr += frame_half;
++- }
++- memcpy(temp, frame, sizeof(unsigned char) * frame_size);
++-
++- num_branches = num_branches << 1;
++- frame_half = frame_half >> 1;
++- stage--;
++ }
++- }
++-
++- // This last part requires at least 16-bit frames.
++- // Smaller frames are useless for SIMD optimization anyways. Just choose GENERIC!
++-
++- // reset pointers to correct positions.
++- frame_ptr = frame;
++- temp_ptr = temp;
++
++- // prefetch first chunk
++- __VOLK_PREFETCH(temp_ptr);
+++ // This last part requires at least 16-bit frames.
+++ // Smaller frames are useless for SIMD optimization anyways. Just choose GENERIC!
++
++- const __m128i shuffle_stage4 = _mm_setr_epi8(0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15);
++- const __m128i mask_stage4 = _mm_set_epi8(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
++- const __m128i mask_stage3 = _mm_set_epi8(0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF);
++- const __m128i mask_stage2 = _mm_set_epi8(0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF);
+++ // reset pointers to correct positions.
+++ frame_ptr = frame;
+++ temp_ptr = temp;
++
++- for(branch = 0; branch < num_branches; ++branch){
++- r_temp0 = _mm_load_si128((__m128i*) temp_ptr);
++-
++- // prefetch next chunk
++- temp_ptr += 16;
+++ // prefetch first chunk
++ __VOLK_PREFETCH(temp_ptr);
++
++- // shuffle once for bit-reversal.
++- r_temp0 = _mm_shuffle_epi8(r_temp0, shuffle_stage4);
++-
++- shifted = _mm_srli_si128(r_temp0, 8);
++- shifted = _mm_and_si128(shifted, mask_stage4);
++- r_frame0 = _mm_xor_si128(shifted, r_temp0);
++-
++- shifted = _mm_srli_si128(r_frame0, 4);
++- shifted = _mm_and_si128(shifted, mask_stage3);
++- r_frame0 = _mm_xor_si128(shifted, r_frame0);
++-
++- shifted = _mm_srli_si128(r_frame0, 2);
++- shifted = _mm_and_si128(shifted, mask_stage2);
++- r_frame0 = _mm_xor_si128(shifted, r_frame0);
++-
++- shifted = _mm_srli_si128(r_frame0, 1);
++- shifted = _mm_and_si128(shifted, mask_stage1);
++- r_frame0 = _mm_xor_si128(shifted, r_frame0);
++-
++- // store result of chunk.
++- _mm_store_si128((__m128i*)frame_ptr, r_frame0);
++- frame_ptr += 16;
++- }
+++ const __m128i shuffle_stage4 =
+++ _mm_setr_epi8(0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15);
+++ const __m128i mask_stage4 = _mm_set_epi8(0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF);
+++ const __m128i mask_stage3 = _mm_set_epi8(0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF);
+++ const __m128i mask_stage2 = _mm_set_epi8(0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF);
+++
+++ for (branch = 0; branch < num_branches; ++branch) {
+++ r_temp0 = _mm_load_si128((__m128i*)temp_ptr);
+++
+++ // prefetch next chunk
+++ temp_ptr += 16;
+++ __VOLK_PREFETCH(temp_ptr);
+++
+++ // shuffle once for bit-reversal.
+++ r_temp0 = _mm_shuffle_epi8(r_temp0, shuffle_stage4);
+++
+++ shifted = _mm_srli_si128(r_temp0, 8);
+++ shifted = _mm_and_si128(shifted, mask_stage4);
+++ r_frame0 = _mm_xor_si128(shifted, r_temp0);
+++
+++ shifted = _mm_srli_si128(r_frame0, 4);
+++ shifted = _mm_and_si128(shifted, mask_stage3);
+++ r_frame0 = _mm_xor_si128(shifted, r_frame0);
+++
+++ shifted = _mm_srli_si128(r_frame0, 2);
+++ shifted = _mm_and_si128(shifted, mask_stage2);
+++ r_frame0 = _mm_xor_si128(shifted, r_frame0);
+++
+++ shifted = _mm_srli_si128(r_frame0, 1);
+++ shifted = _mm_and_si128(shifted, mask_stage1);
+++ r_frame0 = _mm_xor_si128(shifted, r_frame0);
+++
+++ // store result of chunk.
+++ _mm_store_si128((__m128i*)frame_ptr, r_frame0);
+++ frame_ptr += 16;
+++ }
++ }
++ #endif /* LV_HAVE_SSSE3 */
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++
++-static inline void
++-volk_8u_x2_encodeframepolar_8u_a_avx2(unsigned char* frame, unsigned char* temp,
++- unsigned int frame_size)
+++static inline void volk_8u_x2_encodeframepolar_8u_a_avx2(unsigned char* frame,
+++ unsigned char* temp,
+++ unsigned int frame_size)
++ {
++- const unsigned int po2 = log2_of_power_of_2(frame_size);
++-
++- unsigned int stage = po2;
++- unsigned char* frame_ptr = frame;
++- unsigned char* temp_ptr = temp;
++-
++- unsigned int frame_half = frame_size >> 1;
++- unsigned int num_branches = 1;
++- unsigned int branch;
++- unsigned int bit;
++-
++- // prepare constants
++- const __m256i mask_stage1 = _mm256_set_epi8(0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF,
++- 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF);
++-
++- const __m128i mask_stage0 = _mm_set_epi8(0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF, 0x0, 0xFF);
++- // get some SIMD registers to play with.
++- __m256i r_frame0, r_temp0, shifted;
++- __m128i r_temp2, r_frame2, shifted2;
++- {
++- __m256i r_frame1, r_temp1;
++- __m128i r_frame3, r_temp3;
++- const __m256i shuffle_separate = _mm256_setr_epi8(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15,
++- 0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15);
++- const __m128i shuffle_separate128 = _mm_setr_epi8(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15);
++-
++- while(stage > 4){
++- frame_ptr = frame;
++- temp_ptr = temp;
++-
++- // for stage = 5 a branch has 32 elements. So upper stages are even bigger.
++- for(branch = 0; branch < num_branches; ++branch){
++- for(bit = 0; bit < frame_half; bit += 32){
++- if ((frame_half-bit)<32) //if only 16 bits remaining in frame, not 32
++- {
++- r_temp2 = _mm_load_si128((__m128i *) temp_ptr);
++- temp_ptr += 16;
++- r_temp3 = _mm_load_si128((__m128i *) temp_ptr);
++- temp_ptr += 16;
++-
++- shifted2 = _mm_srli_si128(r_temp2, 1);
++- shifted2 = _mm_and_si128(shifted2, mask_stage0);
++- r_temp2 = _mm_xor_si128(shifted2, r_temp2);
++- r_temp2 = _mm_shuffle_epi8(r_temp2, shuffle_separate128);
++-
++- shifted2 = _mm_srli_si128(r_temp3, 1);
++- shifted2 = _mm_and_si128(shifted2, mask_stage0);
++- r_temp3 = _mm_xor_si128(shifted2, r_temp3);
++- r_temp3 = _mm_shuffle_epi8(r_temp3, shuffle_separate128);
++-
++- r_frame2 = _mm_unpacklo_epi64(r_temp2, r_temp3);
++- _mm_store_si128((__m128i*) frame_ptr, r_frame2);
++-
++- r_frame3 = _mm_unpackhi_epi64(r_temp2, r_temp3);
++- _mm_store_si128((__m128i*) (frame_ptr + frame_half), r_frame3);
++- frame_ptr += 16;
++- break;
++- }
++- r_temp0 = _mm256_load_si256((__m256i *) temp_ptr);
++- temp_ptr += 32;
++- r_temp1 = _mm256_load_si256((__m256i *) temp_ptr);
++- temp_ptr += 32;
++-
++- shifted = _mm256_srli_si256(r_temp0, 1);//operate on 128 bit lanes
++- shifted = _mm256_and_si256(shifted, mask_stage1);
++- r_temp0 = _mm256_xor_si256(shifted, r_temp0);
++- r_temp0 = _mm256_shuffle_epi8(r_temp0, shuffle_separate);
++-
++- shifted = _mm256_srli_si256(r_temp1, 1);
++- shifted = _mm256_and_si256(shifted, mask_stage1);
++- r_temp1 = _mm256_xor_si256(shifted, r_temp1);
++- r_temp1 = _mm256_shuffle_epi8(r_temp1, shuffle_separate);
++-
++- r_frame0 = _mm256_unpacklo_epi64(r_temp0, r_temp1);
++- r_temp1 = _mm256_unpackhi_epi64(r_temp0, r_temp1);
++- r_frame0 = _mm256_permute4x64_epi64(r_frame0, 0xd8);
++- r_frame1 = _mm256_permute4x64_epi64(r_temp1, 0xd8);
++-
++- _mm256_store_si256((__m256i*) frame_ptr, r_frame0);
++-
++- _mm256_store_si256((__m256i*) (frame_ptr + frame_half), r_frame1);
++- frame_ptr += 32;
+++ const unsigned int po2 = log2_of_power_of_2(frame_size);
+++
+++ unsigned int stage = po2;
+++ unsigned char* frame_ptr = frame;
+++ unsigned char* temp_ptr = temp;
+++
+++ unsigned int frame_half = frame_size >> 1;
+++ unsigned int num_branches = 1;
+++ unsigned int branch;
+++ unsigned int bit;
+++
+++ // prepare constants
+++ const __m256i mask_stage1 = _mm256_set_epi8(0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF);
+++
+++ const __m128i mask_stage0 = _mm_set_epi8(0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF,
+++ 0x0,
+++ 0xFF);
+++ // get some SIMD registers to play with.
+++ __m256i r_frame0, r_temp0, shifted;
+++ __m128i r_temp2, r_frame2, shifted2;
+++ {
+++ __m256i r_frame1, r_temp1;
+++ __m128i r_frame3, r_temp3;
+++ const __m256i shuffle_separate = _mm256_setr_epi8(0,
+++ 2,
+++ 4,
+++ 6,
+++ 8,
+++ 10,
+++ 12,
+++ 14,
+++ 1,
+++ 3,
+++ 5,
+++ 7,
+++ 9,
+++ 11,
+++ 13,
+++ 15,
+++ 0,
+++ 2,
+++ 4,
+++ 6,
+++ 8,
+++ 10,
+++ 12,
+++ 14,
+++ 1,
+++ 3,
+++ 5,
+++ 7,
+++ 9,
+++ 11,
+++ 13,
+++ 15);
+++ const __m128i shuffle_separate128 =
+++ _mm_setr_epi8(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15);
+++
+++ while (stage > 4) {
+++ frame_ptr = frame;
+++ temp_ptr = temp;
+++
+++ // for stage = 5 a branch has 32 elements. So upper stages are even bigger.
+++ for (branch = 0; branch < num_branches; ++branch) {
+++ for (bit = 0; bit < frame_half; bit += 32) {
+++ if ((frame_half - bit) <
+++ 32) // if only 16 bits remaining in frame, not 32
+++ {
+++ r_temp2 = _mm_load_si128((__m128i*)temp_ptr);
+++ temp_ptr += 16;
+++ r_temp3 = _mm_load_si128((__m128i*)temp_ptr);
+++ temp_ptr += 16;
+++
+++ shifted2 = _mm_srli_si128(r_temp2, 1);
+++ shifted2 = _mm_and_si128(shifted2, mask_stage0);
+++ r_temp2 = _mm_xor_si128(shifted2, r_temp2);
+++ r_temp2 = _mm_shuffle_epi8(r_temp2, shuffle_separate128);
+++
+++ shifted2 = _mm_srli_si128(r_temp3, 1);
+++ shifted2 = _mm_and_si128(shifted2, mask_stage0);
+++ r_temp3 = _mm_xor_si128(shifted2, r_temp3);
+++ r_temp3 = _mm_shuffle_epi8(r_temp3, shuffle_separate128);
+++
+++ r_frame2 = _mm_unpacklo_epi64(r_temp2, r_temp3);
+++ _mm_store_si128((__m128i*)frame_ptr, r_frame2);
+++
+++ r_frame3 = _mm_unpackhi_epi64(r_temp2, r_temp3);
+++ _mm_store_si128((__m128i*)(frame_ptr + frame_half), r_frame3);
+++ frame_ptr += 16;
+++ break;
+++ }
+++ r_temp0 = _mm256_load_si256((__m256i*)temp_ptr);
+++ temp_ptr += 32;
+++ r_temp1 = _mm256_load_si256((__m256i*)temp_ptr);
+++ temp_ptr += 32;
+++
+++ shifted = _mm256_srli_si256(r_temp0, 1); // operate on 128 bit lanes
+++ shifted = _mm256_and_si256(shifted, mask_stage1);
+++ r_temp0 = _mm256_xor_si256(shifted, r_temp0);
+++ r_temp0 = _mm256_shuffle_epi8(r_temp0, shuffle_separate);
+++
+++ shifted = _mm256_srli_si256(r_temp1, 1);
+++ shifted = _mm256_and_si256(shifted, mask_stage1);
+++ r_temp1 = _mm256_xor_si256(shifted, r_temp1);
+++ r_temp1 = _mm256_shuffle_epi8(r_temp1, shuffle_separate);
+++
+++ r_frame0 = _mm256_unpacklo_epi64(r_temp0, r_temp1);
+++ r_temp1 = _mm256_unpackhi_epi64(r_temp0, r_temp1);
+++ r_frame0 = _mm256_permute4x64_epi64(r_frame0, 0xd8);
+++ r_frame1 = _mm256_permute4x64_epi64(r_temp1, 0xd8);
+++
+++ _mm256_store_si256((__m256i*)frame_ptr, r_frame0);
+++
+++ _mm256_store_si256((__m256i*)(frame_ptr + frame_half), r_frame1);
+++ frame_ptr += 32;
+++ }
+++
+++ frame_ptr += frame_half;
+++ }
+++ memcpy(temp, frame, sizeof(unsigned char) * frame_size);
+++
+++ num_branches = num_branches << 1;
+++ frame_half = frame_half >> 1;
+++ stage--;
++ }
++-
++- frame_ptr += frame_half;
++- }
++- memcpy(temp, frame, sizeof(unsigned char) * frame_size);
++-
++- num_branches = num_branches << 1;
++- frame_half = frame_half >> 1;
++- stage--;
++ }
++- }
++-
++- // This last part requires at least 32-bit frames.
++- // Smaller frames are useless for SIMD optimization anyways. Just choose GENERIC!
++
++- // reset pointers to correct positions.
++- frame_ptr = frame;
++- temp_ptr = temp;
+++ // This last part requires at least 32-bit frames.
+++ // Smaller frames are useless for SIMD optimization anyways. Just choose GENERIC!
++
++- // prefetch first chunk.
++- __VOLK_PREFETCH(temp_ptr);
+++ // reset pointers to correct positions.
+++ frame_ptr = frame;
+++ temp_ptr = temp;
++
++- const __m256i shuffle_stage4 = _mm256_setr_epi8(0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15,
++- 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15);
++- const __m256i mask_stage4 = _mm256_set_epi8(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
++- 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
++- const __m256i mask_stage3 = _mm256_set_epi8(0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF,
++- 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF);
++- const __m256i mask_stage2 = _mm256_set_epi8(0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF,
++- 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF, 0x0, 0x0, 0xFF, 0xFF);
++-
++- for(branch = 0; branch < num_branches/2; ++branch){
++- r_temp0 = _mm256_load_si256((__m256i*) temp_ptr);
++-
++- // prefetch next chunk
++- temp_ptr += 32;
+++ // prefetch first chunk.
++ __VOLK_PREFETCH(temp_ptr);
++
++- // shuffle once for bit-reversal.
++- r_temp0 = _mm256_shuffle_epi8(r_temp0, shuffle_stage4);
++-
++- shifted = _mm256_srli_si256(r_temp0, 8); //128 bit lanes
++- shifted = _mm256_and_si256(shifted, mask_stage4);
++- r_frame0 = _mm256_xor_si256(shifted, r_temp0);
++-
++- shifted = _mm256_srli_si256(r_frame0, 4);
++- shifted = _mm256_and_si256(shifted, mask_stage3);
++- r_frame0 = _mm256_xor_si256(shifted, r_frame0);
++-
++- shifted = _mm256_srli_si256(r_frame0, 2);
++- shifted = _mm256_and_si256(shifted, mask_stage2);
++- r_frame0 = _mm256_xor_si256(shifted, r_frame0);
++-
++- shifted = _mm256_srli_si256(r_frame0, 1);
++- shifted = _mm256_and_si256(shifted, mask_stage1);
++- r_frame0 = _mm256_xor_si256(shifted, r_frame0);
++-
++- // store result of chunk.
++- _mm256_store_si256((__m256i*)frame_ptr, r_frame0);
++- frame_ptr += 32;
++- }
+++ const __m256i shuffle_stage4 = _mm256_setr_epi8(0,
+++ 8,
+++ 4,
+++ 12,
+++ 2,
+++ 10,
+++ 6,
+++ 14,
+++ 1,
+++ 9,
+++ 5,
+++ 13,
+++ 3,
+++ 11,
+++ 7,
+++ 15,
+++ 0,
+++ 8,
+++ 4,
+++ 12,
+++ 2,
+++ 10,
+++ 6,
+++ 14,
+++ 1,
+++ 9,
+++ 5,
+++ 13,
+++ 3,
+++ 11,
+++ 7,
+++ 15);
+++ const __m256i mask_stage4 = _mm256_set_epi8(0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF);
+++ const __m256i mask_stage3 = _mm256_set_epi8(0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF,
+++ 0xFF);
+++ const __m256i mask_stage2 = _mm256_set_epi8(0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF,
+++ 0x0,
+++ 0x0,
+++ 0xFF,
+++ 0xFF);
+++
+++ for (branch = 0; branch < num_branches / 2; ++branch) {
+++ r_temp0 = _mm256_load_si256((__m256i*)temp_ptr);
+++
+++ // prefetch next chunk
+++ temp_ptr += 32;
+++ __VOLK_PREFETCH(temp_ptr);
+++
+++ // shuffle once for bit-reversal.
+++ r_temp0 = _mm256_shuffle_epi8(r_temp0, shuffle_stage4);
+++
+++ shifted = _mm256_srli_si256(r_temp0, 8); // 128 bit lanes
+++ shifted = _mm256_and_si256(shifted, mask_stage4);
+++ r_frame0 = _mm256_xor_si256(shifted, r_temp0);
+++
+++ shifted = _mm256_srli_si256(r_frame0, 4);
+++ shifted = _mm256_and_si256(shifted, mask_stage3);
+++ r_frame0 = _mm256_xor_si256(shifted, r_frame0);
+++
+++ shifted = _mm256_srli_si256(r_frame0, 2);
+++ shifted = _mm256_and_si256(shifted, mask_stage2);
+++ r_frame0 = _mm256_xor_si256(shifted, r_frame0);
+++
+++ shifted = _mm256_srli_si256(r_frame0, 1);
+++ shifted = _mm256_and_si256(shifted, mask_stage1);
+++ r_frame0 = _mm256_xor_si256(shifted, r_frame0);
+++
+++ // store result of chunk.
+++ _mm256_store_si256((__m256i*)frame_ptr, r_frame0);
+++ frame_ptr += 32;
+++ }
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++
++-
++ #endif /* VOLK_KERNELS_VOLK_VOLK_8U_X2_ENCODEFRAMEPOLAR_8U_A_H_ */
++diff --git a/kernels/volk/volk_8u_x3_encodepolar_8u_x2.h b/kernels/volk/volk_8u_x3_encodepolar_8u_x2.h
++index 5bccd95..413836e 100644
++--- a/kernels/volk/volk_8u_x3_encodepolar_8u_x2.h
+++++ b/kernels/volk/volk_8u_x3_encodepolar_8u_x2.h
++@@ -29,9 +29,9 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_8u_x3_encodepolar_8u(unsigned char* frame, const unsigned char* frozen_bit_mask, const unsigned char* frozen_bits,
++- * const unsigned char* info_bits, unsigned int frame_size, unsigned int info_bit_size)
++- * \endcode
+++ * void volk_8u_x3_encodepolar_8u(unsigned char* frame, const unsigned char*
+++ * frozen_bit_mask, const unsigned char* frozen_bits, const unsigned char* info_bits,
+++ * unsigned int frame_size, unsigned int info_bit_size) \endcode
++ *
++ * \b Inputs
++ * \li frame: buffer for encoded frame
++@@ -55,14 +55,17 @@
++ * unsigned char* frozen_bit_mask = get_frozen_bit_mask(frame_size, num_frozen_bits);
++ *
++ * // set elements to desired values. Typically all zero.
++- * unsigned char* frozen_bits = (unsigned char) volk_malloc(sizeof(unsigned char) * num_frozen_bits, volk_get_alignment());
+++ * unsigned char* frozen_bits = (unsigned char) volk_malloc(sizeof(unsigned char) *
+++ * num_frozen_bits, volk_get_alignment());
++ *
++- * unsigned char* frame = (unsigned char) volk_malloc(sizeof(unsigned char) * frame_size, volk_get_alignment());
++- * unsigned char* temp = (unsigned char) volk_malloc(sizeof(unsigned char) * frame_size, volk_get_alignment());
+++ * unsigned char* frame = (unsigned char) volk_malloc(sizeof(unsigned char) * frame_size,
+++ * volk_get_alignment()); unsigned char* temp = (unsigned char)
+++ * volk_malloc(sizeof(unsigned char) * frame_size, volk_get_alignment());
++ *
++ * unsigned char* info_bits = get_info_bits_to_encode(num_info_bits);
++ *
++- * volk_8u_x3_encodepolar_8u_x2_generic(frame, temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
+++ * volk_8u_x3_encodepolar_8u_x2_generic(frame, temp, frozen_bit_mask, frozen_bits,
+++ * info_bits, frame_size);
++ *
++ * volk_free(frozen_bit_mask);
++ * volk_free(frozen_bits);
++@@ -77,27 +80,32 @@
++ #include <stdio.h>
++ #include <volk/volk_8u_x2_encodeframepolar_8u.h>
++
++-static inline void
++-interleave_frozen_and_info_bits(unsigned char* target, const unsigned char* frozen_bit_mask,
++- const unsigned char* frozen_bits, const unsigned char* info_bits,
++- const unsigned int frame_size)
+++static inline void interleave_frozen_and_info_bits(unsigned char* target,
+++ const unsigned char* frozen_bit_mask,
+++ const unsigned char* frozen_bits,
+++ const unsigned char* info_bits,
+++ const unsigned int frame_size)
++ {
++- unsigned int bit;
++- for(bit = 0; bit < frame_size; ++bit){
++- *target++ = *frozen_bit_mask++ ? *frozen_bits++ : *info_bits++;
++- }
+++ unsigned int bit;
+++ for (bit = 0; bit < frame_size; ++bit) {
+++ *target++ = *frozen_bit_mask++ ? *frozen_bits++ : *info_bits++;
+++ }
++ }
++
++ #ifdef LV_HAVE_GENERIC
++
++ static inline void
++-volk_8u_x3_encodepolar_8u_x2_generic(unsigned char* frame, unsigned char* temp, const unsigned char* frozen_bit_mask,
++- const unsigned char* frozen_bits, const unsigned char* info_bits,
+++volk_8u_x3_encodepolar_8u_x2_generic(unsigned char* frame,
+++ unsigned char* temp,
+++ const unsigned char* frozen_bit_mask,
+++ const unsigned char* frozen_bits,
+++ const unsigned char* info_bits,
++ unsigned int frame_size)
++ {
++- // interleave
++- interleave_frozen_and_info_bits(temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
++- volk_8u_x2_encodeframepolar_8u_generic(frame, temp, frame_size);
+++ // interleave
+++ interleave_frozen_and_info_bits(
+++ temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
+++ volk_8u_x2_encodeframepolar_8u_generic(frame, temp, frame_size);
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++@@ -106,14 +114,17 @@ volk_8u_x3_encodepolar_8u_x2_generic(unsigned char* frame, unsigned char* temp,
++ #include <tmmintrin.h>
++
++ static inline void
++-volk_8u_x3_encodepolar_8u_x2_u_ssse3(unsigned char* frame, unsigned char* temp,
++- const unsigned char* frozen_bit_mask,
++- const unsigned char* frozen_bits, const unsigned char* info_bits,
++- unsigned int frame_size)
+++volk_8u_x3_encodepolar_8u_x2_u_ssse3(unsigned char* frame,
+++ unsigned char* temp,
+++ const unsigned char* frozen_bit_mask,
+++ const unsigned char* frozen_bits,
+++ const unsigned char* info_bits,
+++ unsigned int frame_size)
++ {
++- // interleave
++- interleave_frozen_and_info_bits(temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
++- volk_8u_x2_encodeframepolar_8u_u_ssse3(frame, temp, frame_size);
+++ // interleave
+++ interleave_frozen_and_info_bits(
+++ temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
+++ volk_8u_x2_encodeframepolar_8u_u_ssse3(frame, temp, frame_size);
++ }
++
++ #endif /* LV_HAVE_SSSE3 */
++@@ -121,13 +132,16 @@ volk_8u_x3_encodepolar_8u_x2_u_ssse3(unsigned char* frame, unsigned char* temp,
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++ static inline void
++-volk_8u_x3_encodepolar_8u_x2_u_avx2(unsigned char* frame, unsigned char* temp,
++- const unsigned char* frozen_bit_mask,
++- const unsigned char* frozen_bits, const unsigned char* info_bits,
++- unsigned int frame_size)
+++volk_8u_x3_encodepolar_8u_x2_u_avx2(unsigned char* frame,
+++ unsigned char* temp,
+++ const unsigned char* frozen_bit_mask,
+++ const unsigned char* frozen_bits,
+++ const unsigned char* info_bits,
+++ unsigned int frame_size)
++ {
++- interleave_frozen_and_info_bits(temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
++- volk_8u_x2_encodeframepolar_8u_u_avx2(frame, temp, frame_size);
+++ interleave_frozen_and_info_bits(
+++ temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
+++ volk_8u_x2_encodeframepolar_8u_u_avx2(frame, temp, frame_size);
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -139,26 +153,32 @@ volk_8u_x3_encodepolar_8u_x2_u_avx2(unsigned char* frame, unsigned char* temp,
++ #ifdef LV_HAVE_SSSE3
++ #include <tmmintrin.h>
++ static inline void
++-volk_8u_x3_encodepolar_8u_x2_a_ssse3(unsigned char* frame, unsigned char* temp,
++- const unsigned char* frozen_bit_mask,
++- const unsigned char* frozen_bits, const unsigned char* info_bits,
++- unsigned int frame_size)
+++volk_8u_x3_encodepolar_8u_x2_a_ssse3(unsigned char* frame,
+++ unsigned char* temp,
+++ const unsigned char* frozen_bit_mask,
+++ const unsigned char* frozen_bits,
+++ const unsigned char* info_bits,
+++ unsigned int frame_size)
++ {
++- interleave_frozen_and_info_bits(temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
++- volk_8u_x2_encodeframepolar_8u_a_ssse3(frame, temp, frame_size);
+++ interleave_frozen_and_info_bits(
+++ temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
+++ volk_8u_x2_encodeframepolar_8u_a_ssse3(frame, temp, frame_size);
++ }
++ #endif /* LV_HAVE_SSSE3 */
++
++ #ifdef LV_HAVE_AVX2
++ #include <immintrin.h>
++ static inline void
++-volk_8u_x3_encodepolar_8u_x2_a_avx2(unsigned char* frame, unsigned char* temp,
++- const unsigned char* frozen_bit_mask,
++- const unsigned char* frozen_bits, const unsigned char* info_bits,
++- unsigned int frame_size)
+++volk_8u_x3_encodepolar_8u_x2_a_avx2(unsigned char* frame,
+++ unsigned char* temp,
+++ const unsigned char* frozen_bit_mask,
+++ const unsigned char* frozen_bits,
+++ const unsigned char* info_bits,
+++ unsigned int frame_size)
++ {
++- interleave_frozen_and_info_bits(temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
++- volk_8u_x2_encodeframepolar_8u_a_avx2(frame, temp, frame_size);
+++ interleave_frozen_and_info_bits(
+++ temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
+++ volk_8u_x2_encodeframepolar_8u_a_avx2(frame, temp, frame_size);
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_8u_x3_encodepolarpuppet_8u.h b/kernels/volk/volk_8u_x3_encodepolarpuppet_8u.h
++index 1f6be2c..1badbf1 100644
++--- a/kernels/volk/volk_8u_x3_encodepolarpuppet_8u.h
+++++ b/kernels/volk/volk_8u_x3_encodepolarpuppet_8u.h
++@@ -29,71 +29,82 @@
++ #include <volk/volk.h>
++ #include <volk/volk_8u_x3_encodepolar_8u_x2.h>
++
++-static inline unsigned int
++-next_lower_power_of_two(const unsigned int val)
+++static inline unsigned int next_lower_power_of_two(const unsigned int val)
++ {
++- // algorithm found and adopted from: http://acius2.blogspot.de/2007/11/calculating-next-power-of-2.html
++- unsigned int res = val;
++- res = (res >> 1) | res;
++- res = (res >> 2) | res;
++- res = (res >> 4) | res;
++- res = (res >> 8) | res;
++- res = (res >> 16) | res;
++- res += 1;
++- return res >> 1;
+++ // algorithm found and adopted from:
+++ // http://acius2.blogspot.de/2007/11/calculating-next-power-of-2.html
+++ unsigned int res = val;
+++ res = (res >> 1) | res;
+++ res = (res >> 2) | res;
+++ res = (res >> 4) | res;
+++ res = (res >> 8) | res;
+++ res = (res >> 16) | res;
+++ res += 1;
+++ return res >> 1;
++ }
++
++-static inline void
++-adjust_frozen_mask(unsigned char* mask, const unsigned int frame_size)
+++static inline void adjust_frozen_mask(unsigned char* mask, const unsigned int frame_size)
++ {
++- // just like the rest of the puppet this function exists for test purposes only.
++- unsigned int i;
++- for(i = 0; i < frame_size; ++i){
++- *mask = (*mask & 0x80) ? 0xFF : 0x00;
++- mask++;
++- }
+++ // just like the rest of the puppet this function exists for test purposes only.
+++ unsigned int i;
+++ for (i = 0; i < frame_size; ++i) {
+++ *mask = (*mask & 0x80) ? 0xFF : 0x00;
+++ mask++;
+++ }
++ }
++
++ #ifdef LV_HAVE_GENERIC
++ static inline void
++-volk_8u_x3_encodepolarpuppet_8u_generic(unsigned char* frame, unsigned char* frozen_bit_mask,
++- const unsigned char* frozen_bits, const unsigned char* info_bits,
++- unsigned int frame_size)
+++volk_8u_x3_encodepolarpuppet_8u_generic(unsigned char* frame,
+++ unsigned char* frozen_bit_mask,
+++ const unsigned char* frozen_bits,
+++ const unsigned char* info_bits,
+++ unsigned int frame_size)
++ {
++- frame_size = next_lower_power_of_two(frame_size);
++- unsigned char* temp = (unsigned char*) volk_malloc(sizeof(unsigned char) * frame_size, volk_get_alignment());
++- adjust_frozen_mask(frozen_bit_mask, frame_size);
++- volk_8u_x3_encodepolar_8u_x2_generic(frame, temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
++- volk_free(temp);
+++ frame_size = next_lower_power_of_two(frame_size);
+++ unsigned char* temp = (unsigned char*)volk_malloc(sizeof(unsigned char) * frame_size,
+++ volk_get_alignment());
+++ adjust_frozen_mask(frozen_bit_mask, frame_size);
+++ volk_8u_x3_encodepolar_8u_x2_generic(
+++ frame, temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
+++ volk_free(temp);
++ }
++ #endif /* LV_HAVE_GENERIC */
++
++
++ #ifdef LV_HAVE_SSSE3
++ static inline void
++-volk_8u_x3_encodepolarpuppet_8u_u_ssse3(unsigned char* frame, unsigned char* frozen_bit_mask,
++- const unsigned char* frozen_bits, const unsigned char* info_bits,
++- unsigned int frame_size)
+++volk_8u_x3_encodepolarpuppet_8u_u_ssse3(unsigned char* frame,
+++ unsigned char* frozen_bit_mask,
+++ const unsigned char* frozen_bits,
+++ const unsigned char* info_bits,
+++ unsigned int frame_size)
++ {
++- frame_size = next_lower_power_of_two(frame_size);
++- unsigned char* temp = (unsigned char*) volk_malloc(sizeof(unsigned char) * frame_size, volk_get_alignment());
++- adjust_frozen_mask(frozen_bit_mask, frame_size);
++- volk_8u_x3_encodepolar_8u_x2_u_ssse3(frame, temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
++- volk_free(temp);
+++ frame_size = next_lower_power_of_two(frame_size);
+++ unsigned char* temp = (unsigned char*)volk_malloc(sizeof(unsigned char) * frame_size,
+++ volk_get_alignment());
+++ adjust_frozen_mask(frozen_bit_mask, frame_size);
+++ volk_8u_x3_encodepolar_8u_x2_u_ssse3(
+++ frame, temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
+++ volk_free(temp);
++ }
++ #endif /* LV_HAVE_SSSE3 */
++
++ #ifdef LV_HAVE_AVX2
++ static inline void
++-volk_8u_x3_encodepolarpuppet_8u_u_avx2(unsigned char* frame, unsigned char* frozen_bit_mask,
++- const unsigned char* frozen_bits, const unsigned char* info_bits,
++- unsigned int frame_size)
+++volk_8u_x3_encodepolarpuppet_8u_u_avx2(unsigned char* frame,
+++ unsigned char* frozen_bit_mask,
+++ const unsigned char* frozen_bits,
+++ const unsigned char* info_bits,
+++ unsigned int frame_size)
++ {
++- frame_size = next_lower_power_of_two(frame_size);
++- unsigned char* temp = (unsigned char*) volk_malloc(sizeof(unsigned char) * frame_size, volk_get_alignment());
++- adjust_frozen_mask(frozen_bit_mask, frame_size);
++- volk_8u_x3_encodepolar_8u_x2_u_avx2(frame, temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
++- volk_free(temp);
+++ frame_size = next_lower_power_of_two(frame_size);
+++ unsigned char* temp = (unsigned char*)volk_malloc(sizeof(unsigned char) * frame_size,
+++ volk_get_alignment());
+++ adjust_frozen_mask(frozen_bit_mask, frame_size);
+++ volk_8u_x3_encodepolar_8u_x2_u_avx2(
+++ frame, temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
+++ volk_free(temp);
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++@@ -104,29 +115,37 @@ volk_8u_x3_encodepolarpuppet_8u_u_avx2(unsigned char* frame, unsigned char* froz
++
++ #ifdef LV_HAVE_SSSE3
++ static inline void
++-volk_8u_x3_encodepolarpuppet_8u_a_ssse3(unsigned char* frame, unsigned char* frozen_bit_mask,
++- const unsigned char* frozen_bits, const unsigned char* info_bits,
++- unsigned int frame_size)
+++volk_8u_x3_encodepolarpuppet_8u_a_ssse3(unsigned char* frame,
+++ unsigned char* frozen_bit_mask,
+++ const unsigned char* frozen_bits,
+++ const unsigned char* info_bits,
+++ unsigned int frame_size)
++ {
++- frame_size = next_lower_power_of_two(frame_size);
++- unsigned char* temp = (unsigned char*) volk_malloc(sizeof(unsigned char) * frame_size, volk_get_alignment());
++- adjust_frozen_mask(frozen_bit_mask, frame_size);
++- volk_8u_x3_encodepolar_8u_x2_a_ssse3(frame, temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
++- volk_free(temp);
+++ frame_size = next_lower_power_of_two(frame_size);
+++ unsigned char* temp = (unsigned char*)volk_malloc(sizeof(unsigned char) * frame_size,
+++ volk_get_alignment());
+++ adjust_frozen_mask(frozen_bit_mask, frame_size);
+++ volk_8u_x3_encodepolar_8u_x2_a_ssse3(
+++ frame, temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
+++ volk_free(temp);
++ }
++ #endif /* LV_HAVE_SSSE3 */
++
++ #ifdef LV_HAVE_AVX2
++ static inline void
++-volk_8u_x3_encodepolarpuppet_8u_a_avx2(unsigned char* frame, unsigned char* frozen_bit_mask,
++- const unsigned char* frozen_bits, const unsigned char* info_bits,
++- unsigned int frame_size)
+++volk_8u_x3_encodepolarpuppet_8u_a_avx2(unsigned char* frame,
+++ unsigned char* frozen_bit_mask,
+++ const unsigned char* frozen_bits,
+++ const unsigned char* info_bits,
+++ unsigned int frame_size)
++ {
++- frame_size = next_lower_power_of_two(frame_size);
++- unsigned char* temp = (unsigned char*) volk_malloc(sizeof(unsigned char) * frame_size, volk_get_alignment());
++- adjust_frozen_mask(frozen_bit_mask, frame_size);
++- volk_8u_x3_encodepolar_8u_x2_a_avx2(frame, temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
++- volk_free(temp);
+++ frame_size = next_lower_power_of_two(frame_size);
+++ unsigned char* temp = (unsigned char*)volk_malloc(sizeof(unsigned char) * frame_size,
+++ volk_get_alignment());
+++ adjust_frozen_mask(frozen_bit_mask, frame_size);
+++ volk_8u_x3_encodepolar_8u_x2_a_avx2(
+++ frame, temp, frozen_bit_mask, frozen_bits, info_bits, frame_size);
+++ volk_free(temp);
++ }
++ #endif /* LV_HAVE_AVX2 */
++
++diff --git a/kernels/volk/volk_8u_x4_conv_k7_r2_8u.h b/kernels/volk/volk_8u_x4_conv_k7_r2_8u.h
++index 029ba75..89460a6 100644
++--- a/kernels/volk/volk_8u_x4_conv_k7_r2_8u.h
+++++ b/kernels/volk/volk_8u_x4_conv_k7_r2_8u.h
++@@ -30,8 +30,9 @@
++ *
++ * <b>Dispatcher Prototype</b>
++ * \code
++- * void volk_8u_x4_conv_k7_r2_8u(unsigned char* Y, unsigned char* X, unsigned char* syms, unsigned char* dec, unsigned int framebits, unsigned int excess, unsigned char* Branchtab)
++- * \endcode
+++ * void volk_8u_x4_conv_k7_r2_8u(unsigned char* Y, unsigned char* X, unsigned char* syms,
+++ * unsigned char* dec, unsigned int framebits, unsigned int excess, unsigned char*
+++ * Branchtab) \endcode
++ *
++ * \b Inputs
++ * \li X: <FIXME>
++@@ -58,67 +59,71 @@
++ #define INCLUDED_volk_8u_x4_conv_k7_r2_8u_H
++
++ typedef union {
++- unsigned char/*DECISIONTYPE*/ t[64/*NUMSTATES*//8/*DECISIONTYPE_BITSIZE*/];
++- unsigned int w[64/*NUMSTATES*//32];
++- unsigned short s[64/*NUMSTATES*//16];
++- unsigned char c[64/*NUMSTATES*//8];
+++ unsigned char /*DECISIONTYPE*/ t[64 /*NUMSTATES*/ / 8 /*DECISIONTYPE_BITSIZE*/];
+++ unsigned int w[64 /*NUMSTATES*/ / 32];
+++ unsigned short s[64 /*NUMSTATES*/ / 16];
+++ unsigned char c[64 /*NUMSTATES*/ / 8];
++ #ifdef _MSC_VER
++ } decision_t;
++ #else
++-} decision_t __attribute__ ((aligned (16)));
+++} decision_t __attribute__((aligned(16)));
++ #endif
++
++
++-static inline void
++-renormalize(unsigned char* X, unsigned char threshold)
+++static inline void renormalize(unsigned char* X, unsigned char threshold)
++ {
++- int NUMSTATES = 64;
++- int i;
++-
++- unsigned char min=X[0];
++- //if(min > threshold) {
++- for(i=0;i<NUMSTATES;i++)
++- if (min>X[i])
++- min=X[i];
++- for(i=0;i<NUMSTATES;i++)
++- X[i]-=min;
++- //}
+++ int NUMSTATES = 64;
+++ int i;
+++
+++ unsigned char min = X[0];
+++ // if(min > threshold) {
+++ for (i = 0; i < NUMSTATES; i++)
+++ if (min > X[i])
+++ min = X[i];
+++ for (i = 0; i < NUMSTATES; i++)
+++ X[i] -= min;
+++ //}
++ }
++
++
++-//helper BFLY for GENERIC version
++-static inline void
++-BFLY(int i, int s, unsigned char * syms, unsigned char *Y,
++- unsigned char *X, decision_t * d, unsigned char* Branchtab)
+++// helper BFLY for GENERIC version
+++static inline void BFLY(int i,
+++ int s,
+++ unsigned char* syms,
+++ unsigned char* Y,
+++ unsigned char* X,
+++ decision_t* d,
+++ unsigned char* Branchtab)
++ {
++- int j, decision0, decision1;
++- unsigned char metric,m0,m1,m2,m3;
+++ int j, decision0, decision1;
+++ unsigned char metric, m0, m1, m2, m3;
++
++- int NUMSTATES = 64;
++- int RATE = 2;
++- int METRICSHIFT = 1;
++- int PRECISIONSHIFT = 2;
+++ int NUMSTATES = 64;
+++ int RATE = 2;
+++ int METRICSHIFT = 1;
+++ int PRECISIONSHIFT = 2;
++
++- metric =0;
++- for(j=0;j<RATE;j++)
++- metric += (Branchtab[i+j*NUMSTATES/2] ^ syms[s*RATE+j])>>METRICSHIFT;
++- metric=metric>>PRECISIONSHIFT;
+++ metric = 0;
+++ for (j = 0; j < RATE; j++)
+++ metric += (Branchtab[i + j * NUMSTATES / 2] ^ syms[s * RATE + j]) >> METRICSHIFT;
+++ metric = metric >> PRECISIONSHIFT;
++
++- unsigned char max = ((RATE*((256 -1)>>METRICSHIFT))>>PRECISIONSHIFT);
+++ unsigned char max = ((RATE * ((256 - 1) >> METRICSHIFT)) >> PRECISIONSHIFT);
++
++- m0 = X[i] + metric;
++- m1 = X[i+NUMSTATES/2] + (max - metric);
++- m2 = X[i] + (max - metric);
++- m3 = X[i+NUMSTATES/2] + metric;
+++ m0 = X[i] + metric;
+++ m1 = X[i + NUMSTATES / 2] + (max - metric);
+++ m2 = X[i] + (max - metric);
+++ m3 = X[i + NUMSTATES / 2] + metric;
++
++- decision0 = (signed int)(m0-m1) > 0;
++- decision1 = (signed int)(m2-m3) > 0;
+++ decision0 = (signed int)(m0 - m1) > 0;
+++ decision1 = (signed int)(m2 - m3) > 0;
++
++- Y[2*i] = decision0 ? m1 : m0;
++- Y[2*i+1] = decision1 ? m3 : m2;
+++ Y[2 * i] = decision0 ? m1 : m0;
+++ Y[2 * i + 1] = decision1 ? m3 : m2;
++
++- d->w[i/(sizeof(unsigned int)*8/2)+s*(sizeof(decision_t)/sizeof(unsigned int))] |=
++- (decision0|decision1<<1) << ((2*i)&(sizeof(unsigned int)*8-1));
+++ d->w[i / (sizeof(unsigned int) * 8 / 2) +
+++ s * (sizeof(decision_t) / sizeof(unsigned int))] |=
+++ (decision0 | decision1 << 1) << ((2 * i) & (sizeof(unsigned int) * 8 - 1));
++ }
++
++
++@@ -127,188 +132,199 @@ BFLY(int i, int s, unsigned char * syms, unsigned char *Y,
++ #include <immintrin.h>
++ #include <stdio.h>
++
++-static inline void
++-volk_8u_x4_conv_k7_r2_8u_avx2(unsigned char* Y, unsigned char* X,
++- unsigned char* syms, unsigned char* dec,
++- unsigned int framebits, unsigned int excess,
++- unsigned char* Branchtab)
+++static inline void volk_8u_x4_conv_k7_r2_8u_avx2(unsigned char* Y,
+++ unsigned char* X,
+++ unsigned char* syms,
+++ unsigned char* dec,
+++ unsigned int framebits,
+++ unsigned int excess,
+++ unsigned char* Branchtab)
++ {
++- unsigned int i9;
++- for(i9 = 0; i9 < ((framebits + excess)>>1); i9++) {
++- unsigned char a75, a81;
++- int a73, a92;
++- int s20, s21;
++- unsigned char *a80, *b6;
++- int *a110, *a91, *a93;
++- __m256i *a112, *a71, *a72, *a77, *a83, *a95;
++- __m256i a86, a87;
++- __m256i a76, a78, a79, a82, a84, a85, a88, a89
++- , a90, d10, d9, m23, m24, m25
++- , m26, s18, s19, s22
++- , s23, s24, s25, t13, t14, t15;
++- a71 = ((__m256i *) X);
++- s18 = *(a71);
++- a72 = (a71 + 1);
++- s19 = *(a72);
++- s22 = _mm256_permute2x128_si256(s18,s19,0x20);
++- s19 = _mm256_permute2x128_si256(s18,s19,0x31);
++- s18 = s22;
++- a73 = (4 * i9);
++- b6 = (syms + a73);
++- a75 = *(b6);
++- a76 = _mm256_set1_epi8(a75);
++- a77 = ((__m256i *) Branchtab);
++- a78 = *(a77);
++- a79 = _mm256_xor_si256(a76, a78);
++- a80 = (b6 + 1);
++- a81 = *(a80);
++- a82 = _mm256_set1_epi8(a81);
++- a83 = (a77 + 1);
++- a84 = *(a83);
++- a85 = _mm256_xor_si256(a82, a84);
++- t13 = _mm256_avg_epu8(a79,a85);
++- a86 = ((__m256i ) t13);
++- a87 = _mm256_srli_epi16(a86, 2);
++- a88 = ((__m256i ) a87);
++- t14 = _mm256_and_si256(a88, _mm256_set1_epi8(63));
++- t15 = _mm256_subs_epu8(_mm256_set1_epi8(63), t14);
++- m23 = _mm256_adds_epu8(s18, t14);
++- m24 = _mm256_adds_epu8(s19, t15);
++- m25 = _mm256_adds_epu8(s18, t15);
++- m26 = _mm256_adds_epu8(s19, t14);
++- a89 = _mm256_min_epu8(m24, m23);
++- d9 = _mm256_cmpeq_epi8(a89, m24);
++- a90 = _mm256_min_epu8(m26, m25);
++- d10 = _mm256_cmpeq_epi8(a90, m26);
++- s22 = _mm256_unpacklo_epi8(d9,d10);
++- s23 = _mm256_unpackhi_epi8(d9,d10);
++- s20 = _mm256_movemask_epi8(_mm256_permute2x128_si256(s22, s23, 0x20));
++- a91 = ((int *) dec);
++- a92 = (4 * i9);
++- a93 = (a91 + a92);
++- *(a93) = s20;
++- s21 = _mm256_movemask_epi8(_mm256_permute2x128_si256(s22, s23, 0x31));
++- a110 = (a93 + 1);
++- *(a110) = s21;
++- s22 = _mm256_unpacklo_epi8(a89, a90);
++- s23 = _mm256_unpackhi_epi8(a89, a90);
++- a95 = ((__m256i *) Y);
++- s24 = _mm256_permute2x128_si256(s22, s23, 0x20);
++- *(a95) = s24;
++- s23 = _mm256_permute2x128_si256(s22, s23, 0x31);
++- a112 = (a95 + 1);
++- *(a112) = s23;
++- if ((((unsigned char *) Y)[0]>210)) {
++- __m256i m5, m6;
++- m5 = ((__m256i *) Y)[0];
++- m5 = _mm256_min_epu8(m5, ((__m256i *) Y)[1]);
++- __m256i m7;
++- m7 = _mm256_min_epu8(_mm256_srli_si256(m5, 8), m5);
++- m7 = ((__m256i ) _mm256_min_epu8(((__m256i ) _mm256_srli_epi64(m7, 32)), ((__m256i ) m7)));
++- m7 = ((__m256i ) _mm256_min_epu8(((__m256i ) _mm256_srli_epi64(m7, 16)), ((__m256i ) m7)));
++- m7 = ((__m256i ) _mm256_min_epu8(((__m256i ) _mm256_srli_epi64(m7, 8)), ((__m256i ) m7)));
++- m7 = _mm256_unpacklo_epi8(m7, m7);
++- m7 = _mm256_shufflelo_epi16(m7, 0);
++- m6 = _mm256_unpacklo_epi64(m7, m7);
++- m6 = _mm256_permute2x128_si256(m6, m6, 0); //copy lower half of m6 to upper half, since above ops operate on 128 bit lanes
++- ((__m256i *) Y)[0] = _mm256_subs_epu8(((__m256i *) Y)[0], m6);
++- ((__m256i *) Y)[1] = _mm256_subs_epu8(((__m256i *) Y)[1], m6);
+++ unsigned int i9;
+++ for (i9 = 0; i9 < ((framebits + excess) >> 1); i9++) {
+++ unsigned char a75, a81;
+++ int a73, a92;
+++ int s20, s21;
+++ unsigned char *a80, *b6;
+++ int *a110, *a91, *a93;
+++ __m256i *a112, *a71, *a72, *a77, *a83, *a95;
+++ __m256i a86, a87;
+++ __m256i a76, a78, a79, a82, a84, a85, a88, a89, a90, d10, d9, m23, m24, m25, m26,
+++ s18, s19, s22, s23, s24, s25, t13, t14, t15;
+++ a71 = ((__m256i*)X);
+++ s18 = *(a71);
+++ a72 = (a71 + 1);
+++ s19 = *(a72);
+++ s22 = _mm256_permute2x128_si256(s18, s19, 0x20);
+++ s19 = _mm256_permute2x128_si256(s18, s19, 0x31);
+++ s18 = s22;
+++ a73 = (4 * i9);
+++ b6 = (syms + a73);
+++ a75 = *(b6);
+++ a76 = _mm256_set1_epi8(a75);
+++ a77 = ((__m256i*)Branchtab);
+++ a78 = *(a77);
+++ a79 = _mm256_xor_si256(a76, a78);
+++ a80 = (b6 + 1);
+++ a81 = *(a80);
+++ a82 = _mm256_set1_epi8(a81);
+++ a83 = (a77 + 1);
+++ a84 = *(a83);
+++ a85 = _mm256_xor_si256(a82, a84);
+++ t13 = _mm256_avg_epu8(a79, a85);
+++ a86 = ((__m256i)t13);
+++ a87 = _mm256_srli_epi16(a86, 2);
+++ a88 = ((__m256i)a87);
+++ t14 = _mm256_and_si256(a88, _mm256_set1_epi8(63));
+++ t15 = _mm256_subs_epu8(_mm256_set1_epi8(63), t14);
+++ m23 = _mm256_adds_epu8(s18, t14);
+++ m24 = _mm256_adds_epu8(s19, t15);
+++ m25 = _mm256_adds_epu8(s18, t15);
+++ m26 = _mm256_adds_epu8(s19, t14);
+++ a89 = _mm256_min_epu8(m24, m23);
+++ d9 = _mm256_cmpeq_epi8(a89, m24);
+++ a90 = _mm256_min_epu8(m26, m25);
+++ d10 = _mm256_cmpeq_epi8(a90, m26);
+++ s22 = _mm256_unpacklo_epi8(d9, d10);
+++ s23 = _mm256_unpackhi_epi8(d9, d10);
+++ s20 = _mm256_movemask_epi8(_mm256_permute2x128_si256(s22, s23, 0x20));
+++ a91 = ((int*)dec);
+++ a92 = (4 * i9);
+++ a93 = (a91 + a92);
+++ *(a93) = s20;
+++ s21 = _mm256_movemask_epi8(_mm256_permute2x128_si256(s22, s23, 0x31));
+++ a110 = (a93 + 1);
+++ *(a110) = s21;
+++ s22 = _mm256_unpacklo_epi8(a89, a90);
+++ s23 = _mm256_unpackhi_epi8(a89, a90);
+++ a95 = ((__m256i*)Y);
+++ s24 = _mm256_permute2x128_si256(s22, s23, 0x20);
+++ *(a95) = s24;
+++ s23 = _mm256_permute2x128_si256(s22, s23, 0x31);
+++ a112 = (a95 + 1);
+++ *(a112) = s23;
+++ if ((((unsigned char*)Y)[0] > 210)) {
+++ __m256i m5, m6;
+++ m5 = ((__m256i*)Y)[0];
+++ m5 = _mm256_min_epu8(m5, ((__m256i*)Y)[1]);
+++ __m256i m7;
+++ m7 = _mm256_min_epu8(_mm256_srli_si256(m5, 8), m5);
+++ m7 = ((__m256i)_mm256_min_epu8(((__m256i)_mm256_srli_epi64(m7, 32)),
+++ ((__m256i)m7)));
+++ m7 = ((__m256i)_mm256_min_epu8(((__m256i)_mm256_srli_epi64(m7, 16)),
+++ ((__m256i)m7)));
+++ m7 = ((__m256i)_mm256_min_epu8(((__m256i)_mm256_srli_epi64(m7, 8)),
+++ ((__m256i)m7)));
+++ m7 = _mm256_unpacklo_epi8(m7, m7);
+++ m7 = _mm256_shufflelo_epi16(m7, 0);
+++ m6 = _mm256_unpacklo_epi64(m7, m7);
+++ m6 = _mm256_permute2x128_si256(
+++ m6, m6, 0); // copy lower half of m6 to upper half, since above ops
+++ // operate on 128 bit lanes
+++ ((__m256i*)Y)[0] = _mm256_subs_epu8(((__m256i*)Y)[0], m6);
+++ ((__m256i*)Y)[1] = _mm256_subs_epu8(((__m256i*)Y)[1], m6);
+++ }
+++ unsigned char a188, a194;
+++ int a205;
+++ int s48, s54;
+++ unsigned char *a187, *a193;
+++ int *a204, *a206, *a223, *b16;
+++ __m256i *a184, *a185, *a190, *a196, *a208, *a225;
+++ __m256i a199, a200;
+++ __m256i a189, a191, a192, a195, a197, a198, a201, a202, a203, d17, d18, m39, m40,
+++ m41, m42, s46, s47, s50, s51, t25, t26, t27;
+++ a184 = ((__m256i*)Y);
+++ s46 = *(a184);
+++ a185 = (a184 + 1);
+++ s47 = *(a185);
+++ s50 = _mm256_permute2x128_si256(s46, s47, 0x20);
+++ s47 = _mm256_permute2x128_si256(s46, s47, 0x31);
+++ s46 = s50;
+++ a187 = (b6 + 2);
+++ a188 = *(a187);
+++ a189 = _mm256_set1_epi8(a188);
+++ a190 = ((__m256i*)Branchtab);
+++ a191 = *(a190);
+++ a192 = _mm256_xor_si256(a189, a191);
+++ a193 = (b6 + 3);
+++ a194 = *(a193);
+++ a195 = _mm256_set1_epi8(a194);
+++ a196 = (a190 + 1);
+++ a197 = *(a196);
+++ a198 = _mm256_xor_si256(a195, a197);
+++ t25 = _mm256_avg_epu8(a192, a198);
+++ a199 = ((__m256i)t25);
+++ a200 = _mm256_srli_epi16(a199, 2);
+++ a201 = ((__m256i)a200);
+++ t26 = _mm256_and_si256(a201, _mm256_set1_epi8(63));
+++ t27 = _mm256_subs_epu8(_mm256_set1_epi8(63), t26);
+++ m39 = _mm256_adds_epu8(s46, t26);
+++ m40 = _mm256_adds_epu8(s47, t27);
+++ m41 = _mm256_adds_epu8(s46, t27);
+++ m42 = _mm256_adds_epu8(s47, t26);
+++ a202 = _mm256_min_epu8(m40, m39);
+++ d17 = _mm256_cmpeq_epi8(a202, m40);
+++ a203 = _mm256_min_epu8(m42, m41);
+++ d18 = _mm256_cmpeq_epi8(a203, m42);
+++ s24 = _mm256_unpacklo_epi8(d17, d18);
+++ s25 = _mm256_unpackhi_epi8(d17, d18);
+++ s48 = _mm256_movemask_epi8(_mm256_permute2x128_si256(s24, s25, 0x20));
+++ a204 = ((int*)dec);
+++ a205 = (4 * i9);
+++ b16 = (a204 + a205);
+++ a206 = (b16 + 2);
+++ *(a206) = s48;
+++ s54 = _mm256_movemask_epi8(_mm256_permute2x128_si256(s24, s25, 0x31));
+++ a223 = (b16 + 3);
+++ *(a223) = s54;
+++ s50 = _mm256_unpacklo_epi8(a202, a203);
+++ s51 = _mm256_unpackhi_epi8(a202, a203);
+++ s25 = _mm256_permute2x128_si256(s50, s51, 0x20);
+++ s51 = _mm256_permute2x128_si256(s50, s51, 0x31);
+++ a208 = ((__m256i*)X);
+++ *(a208) = s25;
+++ a225 = (a208 + 1);
+++ *(a225) = s51;
+++
+++ if ((((unsigned char*)X)[0] > 210)) {
+++ __m256i m12, m13;
+++ m12 = ((__m256i*)X)[0];
+++ m12 = _mm256_min_epu8(m12, ((__m256i*)X)[1]);
+++ __m256i m14;
+++ m14 = _mm256_min_epu8(_mm256_srli_si256(m12, 8), m12);
+++ m14 = ((__m256i)_mm256_min_epu8(((__m256i)_mm256_srli_epi64(m14, 32)),
+++ ((__m256i)m14)));
+++ m14 = ((__m256i)_mm256_min_epu8(((__m256i)_mm256_srli_epi64(m14, 16)),
+++ ((__m256i)m14)));
+++ m14 = ((__m256i)_mm256_min_epu8(((__m256i)_mm256_srli_epi64(m14, 8)),
+++ ((__m256i)m14)));
+++ m14 = _mm256_unpacklo_epi8(m14, m14);
+++ m14 = _mm256_shufflelo_epi16(m14, 0);
+++ m13 = _mm256_unpacklo_epi64(m14, m14);
+++ m13 = _mm256_permute2x128_si256(m13, m13, 0);
+++ ((__m256i*)X)[0] = _mm256_subs_epu8(((__m256i*)X)[0], m13);
+++ ((__m256i*)X)[1] = _mm256_subs_epu8(((__m256i*)X)[1], m13);
+++ }
++ }
++- unsigned char a188, a194;
++- int a205;
++- int s48, s54;
++- unsigned char *a187, *a193;
++- int *a204, *a206, *a223, *b16;
++- __m256i *a184, *a185, *a190, *a196, *a208, *a225;
++- __m256i a199, a200;
++- __m256i a189, a191, a192, a195, a197, a198, a201
++- , a202, a203, d17, d18, m39, m40, m41
++- , m42, s46, s47, s50
++- , s51, t25, t26, t27;
++- a184 = ((__m256i *) Y);
++- s46 = *(a184);
++- a185 = (a184 + 1);
++- s47 = *(a185);
++- s50 = _mm256_permute2x128_si256(s46,s47,0x20);
++- s47 = _mm256_permute2x128_si256(s46,s47,0x31);
++- s46 = s50;
++- a187 = (b6 + 2);
++- a188 = *(a187);
++- a189 = _mm256_set1_epi8(a188);
++- a190 = ((__m256i *) Branchtab);
++- a191 = *(a190);
++- a192 = _mm256_xor_si256(a189, a191);
++- a193 = (b6 + 3);
++- a194 = *(a193);
++- a195 = _mm256_set1_epi8(a194);
++- a196 = (a190 + 1);
++- a197 = *(a196);
++- a198 = _mm256_xor_si256(a195, a197);
++- t25 = _mm256_avg_epu8(a192,a198);
++- a199 = ((__m256i ) t25);
++- a200 = _mm256_srli_epi16(a199, 2);
++- a201 = ((__m256i ) a200);
++- t26 = _mm256_and_si256(a201, _mm256_set1_epi8(63));
++- t27 = _mm256_subs_epu8(_mm256_set1_epi8(63), t26);
++- m39 = _mm256_adds_epu8(s46, t26);
++- m40 = _mm256_adds_epu8(s47, t27);
++- m41 = _mm256_adds_epu8(s46, t27);
++- m42 = _mm256_adds_epu8(s47, t26);
++- a202 = _mm256_min_epu8(m40, m39);
++- d17 = _mm256_cmpeq_epi8(a202, m40);
++- a203 = _mm256_min_epu8(m42, m41);
++- d18 = _mm256_cmpeq_epi8(a203, m42);
++- s24 = _mm256_unpacklo_epi8(d17,d18);
++- s25 = _mm256_unpackhi_epi8(d17,d18);
++- s48 = _mm256_movemask_epi8(_mm256_permute2x128_si256(s24, s25, 0x20));
++- a204 = ((int *) dec);
++- a205 = (4 * i9);
++- b16 = (a204 + a205);
++- a206 = (b16 + 2);
++- *(a206) = s48;
++- s54 = _mm256_movemask_epi8(_mm256_permute2x128_si256(s24, s25, 0x31));
++- a223 = (b16 + 3);
++- *(a223) = s54;
++- s50 = _mm256_unpacklo_epi8(a202, a203);
++- s51 = _mm256_unpackhi_epi8(a202, a203);
++- s25 = _mm256_permute2x128_si256(s50, s51, 0x20);
++- s51 = _mm256_permute2x128_si256(s50, s51, 0x31);
++- a208 = ((__m256i *) X);
++- *(a208) = s25;
++- a225 = (a208 + 1);
++- *(a225) = s51;
++-
++- if ((((unsigned char *) X)[0]>210)) {
++- __m256i m12, m13;
++- m12 = ((__m256i *) X)[0];
++- m12 = _mm256_min_epu8(m12, ((__m256i *) X)[1]);
++- __m256i m14;
++- m14 = _mm256_min_epu8(_mm256_srli_si256(m12, 8), m12);
++- m14 = ((__m256i ) _mm256_min_epu8(((__m256i ) _mm256_srli_epi64(m14, 32)), ((__m256i ) m14)));
++- m14 = ((__m256i ) _mm256_min_epu8(((__m256i ) _mm256_srli_epi64(m14, 16)), ((__m256i ) m14)));
++- m14 = ((__m256i ) _mm256_min_epu8(((__m256i ) _mm256_srli_epi64(m14, 8)), ((__m256i ) m14)));
++- m14 = _mm256_unpacklo_epi8(m14, m14);
++- m14 = _mm256_shufflelo_epi16(m14, 0);
++- m13 = _mm256_unpacklo_epi64(m14, m14);
++- m13 = _mm256_permute2x128_si256(m13, m13, 0);
++- ((__m256i *) X)[0] = _mm256_subs_epu8(((__m256i *) X)[0], m13);
++- ((__m256i *) X)[1] = _mm256_subs_epu8(((__m256i *) X)[1], m13);
++- }
++- }
++-
++- renormalize(X, 210);
++
++- unsigned int j;
++- for(j=0; j < (framebits + excess) % 2; ++j) {
++- int i;
++- for(i=0;i<64/2;i++){
++- BFLY(i, (((framebits+excess) >> 1) << 1) + j , syms, Y, X, (decision_t *)dec, Branchtab);
+++ renormalize(X, 210);
+++
+++ unsigned int j;
+++ for (j = 0; j < (framebits + excess) % 2; ++j) {
+++ int i;
+++ for (i = 0; i < 64 / 2; i++) {
+++ BFLY(i,
+++ (((framebits + excess) >> 1) << 1) + j,
+++ syms,
+++ Y,
+++ X,
+++ (decision_t*)dec,
+++ Branchtab);
+++ }
+++
+++ renormalize(Y, 210);
++ }
++-
++- renormalize(Y, 210);
++-
++- }
++- /*skip*/
+++ /*skip*/
++ }
++
++ #endif /*LV_HAVE_AVX2*/
++@@ -316,295 +332,300 @@ volk_8u_x4_conv_k7_r2_8u_avx2(unsigned char* Y, unsigned char* X,
++
++ #if LV_HAVE_SSE3
++
++-#include <pmmintrin.h>
++ #include <emmintrin.h>
++-#include <xmmintrin.h>
++ #include <mmintrin.h>
+++#include <pmmintrin.h>
++ #include <stdio.h>
+++#include <xmmintrin.h>
++
++-static inline void
++-volk_8u_x4_conv_k7_r2_8u_spiral(unsigned char* Y, unsigned char* X,
++- unsigned char* syms, unsigned char* dec,
++- unsigned int framebits, unsigned int excess,
++- unsigned char* Branchtab)
+++static inline void volk_8u_x4_conv_k7_r2_8u_spiral(unsigned char* Y,
+++ unsigned char* X,
+++ unsigned char* syms,
+++ unsigned char* dec,
+++ unsigned int framebits,
+++ unsigned int excess,
+++ unsigned char* Branchtab)
++ {
++- unsigned int i9;
++- for(i9 = 0; i9 < ((framebits + excess) >> 1); i9++) {
++- unsigned char a75, a81;
++- int a73, a92;
++- short int s20, s21, s26, s27;
++- unsigned char *a74, *a80, *b6;
++- short int *a110, *a111, *a91, *a93, *a94;
++- __m128i *a102, *a112, *a113, *a71, *a72, *a77, *a83
++- , *a95, *a96, *a97, *a98, *a99;
++- __m128i a105, a106, a86, a87;
++- __m128i a100, a101, a103, a104, a107, a108, a109
++- , a76, a78, a79, a82, a84, a85, a88, a89
++- , a90, d10, d11, d12, d9, m23, m24, m25
++- , m26, m27, m28, m29, m30, s18, s19, s22
++- , s23, s24, s25, s28, s29, t13, t14, t15
++- , t16, t17, t18;
++- a71 = ((__m128i *) X);
++- s18 = *(a71);
++- a72 = (a71 + 2);
++- s19 = *(a72);
++- a73 = (4 * i9);
++- a74 = (syms + a73);
++- a75 = *(a74);
++- a76 = _mm_set1_epi8(a75);
++- a77 = ((__m128i *) Branchtab);
++- a78 = *(a77);
++- a79 = _mm_xor_si128(a76, a78);
++- b6 = (a73 + syms);
++- a80 = (b6 + 1);
++- a81 = *(a80);
++- a82 = _mm_set1_epi8(a81);
++- a83 = (a77 + 2);
++- a84 = *(a83);
++- a85 = _mm_xor_si128(a82, a84);
++- t13 = _mm_avg_epu8(a79,a85);
++- a86 = ((__m128i ) t13);
++- a87 = _mm_srli_epi16(a86, 2);
++- a88 = ((__m128i ) a87);
++- t14 = _mm_and_si128(a88, _mm_set_epi8(63, 63, 63, 63, 63, 63, 63
++- , 63, 63, 63, 63, 63, 63, 63, 63
++- , 63));
++- t15 = _mm_subs_epu8(_mm_set_epi8(63, 63, 63, 63, 63, 63, 63
++- , 63, 63, 63, 63, 63, 63, 63, 63
++- , 63), t14);
++- m23 = _mm_adds_epu8(s18, t14);
++- m24 = _mm_adds_epu8(s19, t15);
++- m25 = _mm_adds_epu8(s18, t15);
++- m26 = _mm_adds_epu8(s19, t14);
++- a89 = _mm_min_epu8(m24, m23);
++- d9 = _mm_cmpeq_epi8(a89, m24);
++- a90 = _mm_min_epu8(m26, m25);
++- d10 = _mm_cmpeq_epi8(a90, m26);
++- s20 = _mm_movemask_epi8(_mm_unpacklo_epi8(d9,d10));
++- a91 = ((short int *) dec);
++- a92 = (8 * i9);
++- a93 = (a91 + a92);
++- *(a93) = s20;
++- s21 = _mm_movemask_epi8(_mm_unpackhi_epi8(d9,d10));
++- a94 = (a93 + 1);
++- *(a94) = s21;
++- s22 = _mm_unpacklo_epi8(a89, a90);
++- s23 = _mm_unpackhi_epi8(a89, a90);
++- a95 = ((__m128i *) Y);
++- *(a95) = s22;
++- a96 = (a95 + 1);
++- *(a96) = s23;
++- a97 = (a71 + 1);
++- s24 = *(a97);
++- a98 = (a71 + 3);
++- s25 = *(a98);
++- a99 = (a77 + 1);
++- a100 = *(a99);
++- a101 = _mm_xor_si128(a76, a100);
++- a102 = (a77 + 3);
++- a103 = *(a102);
++- a104 = _mm_xor_si128(a82, a103);
++- t16 = _mm_avg_epu8(a101,a104);
++- a105 = ((__m128i ) t16);
++- a106 = _mm_srli_epi16(a105, 2);
++- a107 = ((__m128i ) a106);
++- t17 = _mm_and_si128(a107, _mm_set_epi8(63, 63, 63, 63, 63, 63, 63
++- , 63, 63, 63, 63, 63, 63, 63, 63
++- , 63));
++- t18 = _mm_subs_epu8(_mm_set_epi8(63, 63, 63, 63, 63, 63, 63
++- , 63, 63, 63, 63, 63, 63, 63, 63
++- , 63), t17);
++- m27 = _mm_adds_epu8(s24, t17);
++- m28 = _mm_adds_epu8(s25, t18);
++- m29 = _mm_adds_epu8(s24, t18);
++- m30 = _mm_adds_epu8(s25, t17);
++- a108 = _mm_min_epu8(m28, m27);
++- d11 = _mm_cmpeq_epi8(a108, m28);
++- a109 = _mm_min_epu8(m30, m29);
++- d12 = _mm_cmpeq_epi8(a109, m30);
++- s26 = _mm_movemask_epi8(_mm_unpacklo_epi8(d11,d12));
++- a110 = (a93 + 2);
++- *(a110) = s26;
++- s27 = _mm_movemask_epi8(_mm_unpackhi_epi8(d11,d12));
++- a111 = (a93 + 3);
++- *(a111) = s27;
++- s28 = _mm_unpacklo_epi8(a108, a109);
++- s29 = _mm_unpackhi_epi8(a108, a109);
++- a112 = (a95 + 2);
++- *(a112) = s28;
++- a113 = (a95 + 3);
++- *(a113) = s29;
++- if ((((unsigned char *) Y)[0]>210)) {
++- __m128i m5, m6;
++- m5 = ((__m128i *) Y)[0];
++- m5 = _mm_min_epu8(m5, ((__m128i *) Y)[1]);
++- m5 = _mm_min_epu8(m5, ((__m128i *) Y)[2]);
++- m5 = _mm_min_epu8(m5, ((__m128i *) Y)[3]);
++- __m128i m7;
++- m7 = _mm_min_epu8(_mm_srli_si128(m5, 8), m5);
++- m7 = ((__m128i ) _mm_min_epu8(((__m128i ) _mm_srli_epi64(m7, 32)), ((__m128i ) m7)));
++- m7 = ((__m128i ) _mm_min_epu8(((__m128i ) _mm_srli_epi64(m7, 16)), ((__m128i ) m7)));
++- m7 = ((__m128i ) _mm_min_epu8(((__m128i ) _mm_srli_epi64(m7, 8)), ((__m128i ) m7)));
++- m7 = _mm_unpacklo_epi8(m7, m7);
++- m7 = _mm_shufflelo_epi16(m7, _MM_SHUFFLE(0, 0, 0, 0));
++- m6 = _mm_unpacklo_epi64(m7, m7);
++- ((__m128i *) Y)[0] = _mm_subs_epu8(((__m128i *) Y)[0], m6);
++- ((__m128i *) Y)[1] = _mm_subs_epu8(((__m128i *) Y)[1], m6);
++- ((__m128i *) Y)[2] = _mm_subs_epu8(((__m128i *) Y)[2], m6);
++- ((__m128i *) Y)[3] = _mm_subs_epu8(((__m128i *) Y)[3], m6);
++- }
++- unsigned char a188, a194;
++- int a186, a205;
++- short int s48, s49, s54, s55;
++- unsigned char *a187, *a193, *b15;
++- short int *a204, *a206, *a207, *a223, *a224, *b16;
++- __m128i *a184, *a185, *a190, *a196, *a208, *a209, *a210
++- , *a211, *a212, *a215, *a225, *a226;
++- __m128i a199, a200, a218, a219;
++- __m128i a189, a191, a192, a195, a197, a198, a201
++- , a202, a203, a213, a214, a216, a217, a220, a221
++- , a222, d17, d18, d19, d20, m39, m40, m41
++- , m42, m43, m44, m45, m46, s46, s47, s50
++- , s51, s52, s53, s56, s57, t25, t26, t27
++- , t28, t29, t30;
++- a184 = ((__m128i *) Y);
++- s46 = *(a184);
++- a185 = (a184 + 2);
++- s47 = *(a185);
++- a186 = (4 * i9);
++- b15 = (a186 + syms);
++- a187 = (b15 + 2);
++- a188 = *(a187);
++- a189 = _mm_set1_epi8(a188);
++- a190 = ((__m128i *) Branchtab);
++- a191 = *(a190);
++- a192 = _mm_xor_si128(a189, a191);
++- a193 = (b15 + 3);
++- a194 = *(a193);
++- a195 = _mm_set1_epi8(a194);
++- a196 = (a190 + 2);
++- a197 = *(a196);
++- a198 = _mm_xor_si128(a195, a197);
++- t25 = _mm_avg_epu8(a192,a198);
++- a199 = ((__m128i ) t25);
++- a200 = _mm_srli_epi16(a199, 2);
++- a201 = ((__m128i ) a200);
++- t26 = _mm_and_si128(a201, _mm_set_epi8(63, 63, 63, 63, 63, 63, 63
++- , 63, 63, 63, 63, 63, 63, 63, 63
++- , 63));
++- t27 = _mm_subs_epu8(_mm_set_epi8(63, 63, 63, 63, 63, 63, 63
++- , 63, 63, 63, 63, 63, 63, 63, 63
++- , 63), t26);
++- m39 = _mm_adds_epu8(s46, t26);
++- m40 = _mm_adds_epu8(s47, t27);
++- m41 = _mm_adds_epu8(s46, t27);
++- m42 = _mm_adds_epu8(s47, t26);
++- a202 = _mm_min_epu8(m40, m39);
++- d17 = _mm_cmpeq_epi8(a202, m40);
++- a203 = _mm_min_epu8(m42, m41);
++- d18 = _mm_cmpeq_epi8(a203, m42);
++- s48 = _mm_movemask_epi8(_mm_unpacklo_epi8(d17,d18));
++- a204 = ((short int *) dec);
++- a205 = (8 * i9);
++- b16 = (a204 + a205);
++- a206 = (b16 + 4);
++- *(a206) = s48;
++- s49 = _mm_movemask_epi8(_mm_unpackhi_epi8(d17,d18));
++- a207 = (b16 + 5);
++- *(a207) = s49;
++- s50 = _mm_unpacklo_epi8(a202, a203);
++- s51 = _mm_unpackhi_epi8(a202, a203);
++- a208 = ((__m128i *) X);
++- *(a208) = s50;
++- a209 = (a208 + 1);
++- *(a209) = s51;
++- a210 = (a184 + 1);
++- s52 = *(a210);
++- a211 = (a184 + 3);
++- s53 = *(a211);
++- a212 = (a190 + 1);
++- a213 = *(a212);
++- a214 = _mm_xor_si128(a189, a213);
++- a215 = (a190 + 3);
++- a216 = *(a215);
++- a217 = _mm_xor_si128(a195, a216);
++- t28 = _mm_avg_epu8(a214,a217);
++- a218 = ((__m128i ) t28);
++- a219 = _mm_srli_epi16(a218, 2);
++- a220 = ((__m128i ) a219);
++- t29 = _mm_and_si128(a220, _mm_set_epi8(63, 63, 63, 63, 63, 63, 63
++- , 63, 63, 63, 63, 63, 63, 63, 63
++- , 63));
++- t30 = _mm_subs_epu8(_mm_set_epi8(63, 63, 63, 63, 63, 63, 63
++- , 63, 63, 63, 63, 63, 63, 63, 63
++- , 63), t29);
++- m43 = _mm_adds_epu8(s52, t29);
++- m44 = _mm_adds_epu8(s53, t30);
++- m45 = _mm_adds_epu8(s52, t30);
++- m46 = _mm_adds_epu8(s53, t29);
++- a221 = _mm_min_epu8(m44, m43);
++- d19 = _mm_cmpeq_epi8(a221, m44);
++- a222 = _mm_min_epu8(m46, m45);
++- d20 = _mm_cmpeq_epi8(a222, m46);
++- s54 = _mm_movemask_epi8(_mm_unpacklo_epi8(d19,d20));
++- a223 = (b16 + 6);
++- *(a223) = s54;
++- s55 = _mm_movemask_epi8(_mm_unpackhi_epi8(d19,d20));
++- a224 = (b16 + 7);
++- *(a224) = s55;
++- s56 = _mm_unpacklo_epi8(a221, a222);
++- s57 = _mm_unpackhi_epi8(a221, a222);
++- a225 = (a208 + 2);
++- *(a225) = s56;
++- a226 = (a208 + 3);
++- *(a226) = s57;
++- if ((((unsigned char *) X)[0]>210)) {
++- __m128i m12, m13;
++- m12 = ((__m128i *) X)[0];
++- m12 = _mm_min_epu8(m12, ((__m128i *) X)[1]);
++- m12 = _mm_min_epu8(m12, ((__m128i *) X)[2]);
++- m12 = _mm_min_epu8(m12, ((__m128i *) X)[3]);
++- __m128i m14;
++- m14 = _mm_min_epu8(_mm_srli_si128(m12, 8), m12);
++- m14 = ((__m128i ) _mm_min_epu8(((__m128i ) _mm_srli_epi64(m14, 32)), ((__m128i ) m14)));
++- m14 = ((__m128i ) _mm_min_epu8(((__m128i ) _mm_srli_epi64(m14, 16)), ((__m128i ) m14)));
++- m14 = ((__m128i ) _mm_min_epu8(((__m128i ) _mm_srli_epi64(m14, 8)), ((__m128i ) m14)));
++- m14 = _mm_unpacklo_epi8(m14, m14);
++- m14 = _mm_shufflelo_epi16(m14, _MM_SHUFFLE(0, 0, 0, 0));
++- m13 = _mm_unpacklo_epi64(m14, m14);
++- ((__m128i *) X)[0] = _mm_subs_epu8(((__m128i *) X)[0], m13);
++- ((__m128i *) X)[1] = _mm_subs_epu8(((__m128i *) X)[1], m13);
++- ((__m128i *) X)[2] = _mm_subs_epu8(((__m128i *) X)[2], m13);
++- ((__m128i *) X)[3] = _mm_subs_epu8(((__m128i *) X)[3], m13);
+++ unsigned int i9;
+++ for (i9 = 0; i9 < ((framebits + excess) >> 1); i9++) {
+++ unsigned char a75, a81;
+++ int a73, a92;
+++ short int s20, s21, s26, s27;
+++ unsigned char *a74, *a80, *b6;
+++ short int *a110, *a111, *a91, *a93, *a94;
+++ __m128i *a102, *a112, *a113, *a71, *a72, *a77, *a83, *a95, *a96, *a97, *a98, *a99;
+++ __m128i a105, a106, a86, a87;
+++ __m128i a100, a101, a103, a104, a107, a108, a109, a76, a78, a79, a82, a84, a85,
+++ a88, a89, a90, d10, d11, d12, d9, m23, m24, m25, m26, m27, m28, m29, m30, s18,
+++ s19, s22, s23, s24, s25, s28, s29, t13, t14, t15, t16, t17, t18;
+++ a71 = ((__m128i*)X);
+++ s18 = *(a71);
+++ a72 = (a71 + 2);
+++ s19 = *(a72);
+++ a73 = (4 * i9);
+++ a74 = (syms + a73);
+++ a75 = *(a74);
+++ a76 = _mm_set1_epi8(a75);
+++ a77 = ((__m128i*)Branchtab);
+++ a78 = *(a77);
+++ a79 = _mm_xor_si128(a76, a78);
+++ b6 = (a73 + syms);
+++ a80 = (b6 + 1);
+++ a81 = *(a80);
+++ a82 = _mm_set1_epi8(a81);
+++ a83 = (a77 + 2);
+++ a84 = *(a83);
+++ a85 = _mm_xor_si128(a82, a84);
+++ t13 = _mm_avg_epu8(a79, a85);
+++ a86 = ((__m128i)t13);
+++ a87 = _mm_srli_epi16(a86, 2);
+++ a88 = ((__m128i)a87);
+++ t14 = _mm_and_si128(
+++ a88,
+++ _mm_set_epi8(63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63));
+++ t15 = _mm_subs_epu8(
+++ _mm_set_epi8(63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63),
+++ t14);
+++ m23 = _mm_adds_epu8(s18, t14);
+++ m24 = _mm_adds_epu8(s19, t15);
+++ m25 = _mm_adds_epu8(s18, t15);
+++ m26 = _mm_adds_epu8(s19, t14);
+++ a89 = _mm_min_epu8(m24, m23);
+++ d9 = _mm_cmpeq_epi8(a89, m24);
+++ a90 = _mm_min_epu8(m26, m25);
+++ d10 = _mm_cmpeq_epi8(a90, m26);
+++ s20 = _mm_movemask_epi8(_mm_unpacklo_epi8(d9, d10));
+++ a91 = ((short int*)dec);
+++ a92 = (8 * i9);
+++ a93 = (a91 + a92);
+++ *(a93) = s20;
+++ s21 = _mm_movemask_epi8(_mm_unpackhi_epi8(d9, d10));
+++ a94 = (a93 + 1);
+++ *(a94) = s21;
+++ s22 = _mm_unpacklo_epi8(a89, a90);
+++ s23 = _mm_unpackhi_epi8(a89, a90);
+++ a95 = ((__m128i*)Y);
+++ *(a95) = s22;
+++ a96 = (a95 + 1);
+++ *(a96) = s23;
+++ a97 = (a71 + 1);
+++ s24 = *(a97);
+++ a98 = (a71 + 3);
+++ s25 = *(a98);
+++ a99 = (a77 + 1);
+++ a100 = *(a99);
+++ a101 = _mm_xor_si128(a76, a100);
+++ a102 = (a77 + 3);
+++ a103 = *(a102);
+++ a104 = _mm_xor_si128(a82, a103);
+++ t16 = _mm_avg_epu8(a101, a104);
+++ a105 = ((__m128i)t16);
+++ a106 = _mm_srli_epi16(a105, 2);
+++ a107 = ((__m128i)a106);
+++ t17 = _mm_and_si128(
+++ a107,
+++ _mm_set_epi8(63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63));
+++ t18 = _mm_subs_epu8(
+++ _mm_set_epi8(63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63),
+++ t17);
+++ m27 = _mm_adds_epu8(s24, t17);
+++ m28 = _mm_adds_epu8(s25, t18);
+++ m29 = _mm_adds_epu8(s24, t18);
+++ m30 = _mm_adds_epu8(s25, t17);
+++ a108 = _mm_min_epu8(m28, m27);
+++ d11 = _mm_cmpeq_epi8(a108, m28);
+++ a109 = _mm_min_epu8(m30, m29);
+++ d12 = _mm_cmpeq_epi8(a109, m30);
+++ s26 = _mm_movemask_epi8(_mm_unpacklo_epi8(d11, d12));
+++ a110 = (a93 + 2);
+++ *(a110) = s26;
+++ s27 = _mm_movemask_epi8(_mm_unpackhi_epi8(d11, d12));
+++ a111 = (a93 + 3);
+++ *(a111) = s27;
+++ s28 = _mm_unpacklo_epi8(a108, a109);
+++ s29 = _mm_unpackhi_epi8(a108, a109);
+++ a112 = (a95 + 2);
+++ *(a112) = s28;
+++ a113 = (a95 + 3);
+++ *(a113) = s29;
+++ if ((((unsigned char*)Y)[0] > 210)) {
+++ __m128i m5, m6;
+++ m5 = ((__m128i*)Y)[0];
+++ m5 = _mm_min_epu8(m5, ((__m128i*)Y)[1]);
+++ m5 = _mm_min_epu8(m5, ((__m128i*)Y)[2]);
+++ m5 = _mm_min_epu8(m5, ((__m128i*)Y)[3]);
+++ __m128i m7;
+++ m7 = _mm_min_epu8(_mm_srli_si128(m5, 8), m5);
+++ m7 =
+++ ((__m128i)_mm_min_epu8(((__m128i)_mm_srli_epi64(m7, 32)), ((__m128i)m7)));
+++ m7 =
+++ ((__m128i)_mm_min_epu8(((__m128i)_mm_srli_epi64(m7, 16)), ((__m128i)m7)));
+++ m7 = ((__m128i)_mm_min_epu8(((__m128i)_mm_srli_epi64(m7, 8)), ((__m128i)m7)));
+++ m7 = _mm_unpacklo_epi8(m7, m7);
+++ m7 = _mm_shufflelo_epi16(m7, _MM_SHUFFLE(0, 0, 0, 0));
+++ m6 = _mm_unpacklo_epi64(m7, m7);
+++ ((__m128i*)Y)[0] = _mm_subs_epu8(((__m128i*)Y)[0], m6);
+++ ((__m128i*)Y)[1] = _mm_subs_epu8(((__m128i*)Y)[1], m6);
+++ ((__m128i*)Y)[2] = _mm_subs_epu8(((__m128i*)Y)[2], m6);
+++ ((__m128i*)Y)[3] = _mm_subs_epu8(((__m128i*)Y)[3], m6);
+++ }
+++ unsigned char a188, a194;
+++ int a186, a205;
+++ short int s48, s49, s54, s55;
+++ unsigned char *a187, *a193, *b15;
+++ short int *a204, *a206, *a207, *a223, *a224, *b16;
+++ __m128i *a184, *a185, *a190, *a196, *a208, *a209, *a210, *a211, *a212, *a215,
+++ *a225, *a226;
+++ __m128i a199, a200, a218, a219;
+++ __m128i a189, a191, a192, a195, a197, a198, a201, a202, a203, a213, a214, a216,
+++ a217, a220, a221, a222, d17, d18, d19, d20, m39, m40, m41, m42, m43, m44, m45,
+++ m46, s46, s47, s50, s51, s52, s53, s56, s57, t25, t26, t27, t28, t29, t30;
+++ a184 = ((__m128i*)Y);
+++ s46 = *(a184);
+++ a185 = (a184 + 2);
+++ s47 = *(a185);
+++ a186 = (4 * i9);
+++ b15 = (a186 + syms);
+++ a187 = (b15 + 2);
+++ a188 = *(a187);
+++ a189 = _mm_set1_epi8(a188);
+++ a190 = ((__m128i*)Branchtab);
+++ a191 = *(a190);
+++ a192 = _mm_xor_si128(a189, a191);
+++ a193 = (b15 + 3);
+++ a194 = *(a193);
+++ a195 = _mm_set1_epi8(a194);
+++ a196 = (a190 + 2);
+++ a197 = *(a196);
+++ a198 = _mm_xor_si128(a195, a197);
+++ t25 = _mm_avg_epu8(a192, a198);
+++ a199 = ((__m128i)t25);
+++ a200 = _mm_srli_epi16(a199, 2);
+++ a201 = ((__m128i)a200);
+++ t26 = _mm_and_si128(
+++ a201,
+++ _mm_set_epi8(63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63));
+++ t27 = _mm_subs_epu8(
+++ _mm_set_epi8(63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63),
+++ t26);
+++ m39 = _mm_adds_epu8(s46, t26);
+++ m40 = _mm_adds_epu8(s47, t27);
+++ m41 = _mm_adds_epu8(s46, t27);
+++ m42 = _mm_adds_epu8(s47, t26);
+++ a202 = _mm_min_epu8(m40, m39);
+++ d17 = _mm_cmpeq_epi8(a202, m40);
+++ a203 = _mm_min_epu8(m42, m41);
+++ d18 = _mm_cmpeq_epi8(a203, m42);
+++ s48 = _mm_movemask_epi8(_mm_unpacklo_epi8(d17, d18));
+++ a204 = ((short int*)dec);
+++ a205 = (8 * i9);
+++ b16 = (a204 + a205);
+++ a206 = (b16 + 4);
+++ *(a206) = s48;
+++ s49 = _mm_movemask_epi8(_mm_unpackhi_epi8(d17, d18));
+++ a207 = (b16 + 5);
+++ *(a207) = s49;
+++ s50 = _mm_unpacklo_epi8(a202, a203);
+++ s51 = _mm_unpackhi_epi8(a202, a203);
+++ a208 = ((__m128i*)X);
+++ *(a208) = s50;
+++ a209 = (a208 + 1);
+++ *(a209) = s51;
+++ a210 = (a184 + 1);
+++ s52 = *(a210);
+++ a211 = (a184 + 3);
+++ s53 = *(a211);
+++ a212 = (a190 + 1);
+++ a213 = *(a212);
+++ a214 = _mm_xor_si128(a189, a213);
+++ a215 = (a190 + 3);
+++ a216 = *(a215);
+++ a217 = _mm_xor_si128(a195, a216);
+++ t28 = _mm_avg_epu8(a214, a217);
+++ a218 = ((__m128i)t28);
+++ a219 = _mm_srli_epi16(a218, 2);
+++ a220 = ((__m128i)a219);
+++ t29 = _mm_and_si128(
+++ a220,
+++ _mm_set_epi8(63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63));
+++ t30 = _mm_subs_epu8(
+++ _mm_set_epi8(63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63),
+++ t29);
+++ m43 = _mm_adds_epu8(s52, t29);
+++ m44 = _mm_adds_epu8(s53, t30);
+++ m45 = _mm_adds_epu8(s52, t30);
+++ m46 = _mm_adds_epu8(s53, t29);
+++ a221 = _mm_min_epu8(m44, m43);
+++ d19 = _mm_cmpeq_epi8(a221, m44);
+++ a222 = _mm_min_epu8(m46, m45);
+++ d20 = _mm_cmpeq_epi8(a222, m46);
+++ s54 = _mm_movemask_epi8(_mm_unpacklo_epi8(d19, d20));
+++ a223 = (b16 + 6);
+++ *(a223) = s54;
+++ s55 = _mm_movemask_epi8(_mm_unpackhi_epi8(d19, d20));
+++ a224 = (b16 + 7);
+++ *(a224) = s55;
+++ s56 = _mm_unpacklo_epi8(a221, a222);
+++ s57 = _mm_unpackhi_epi8(a221, a222);
+++ a225 = (a208 + 2);
+++ *(a225) = s56;
+++ a226 = (a208 + 3);
+++ *(a226) = s57;
+++ if ((((unsigned char*)X)[0] > 210)) {
+++ __m128i m12, m13;
+++ m12 = ((__m128i*)X)[0];
+++ m12 = _mm_min_epu8(m12, ((__m128i*)X)[1]);
+++ m12 = _mm_min_epu8(m12, ((__m128i*)X)[2]);
+++ m12 = _mm_min_epu8(m12, ((__m128i*)X)[3]);
+++ __m128i m14;
+++ m14 = _mm_min_epu8(_mm_srli_si128(m12, 8), m12);
+++ m14 = ((__m128i)_mm_min_epu8(((__m128i)_mm_srli_epi64(m14, 32)),
+++ ((__m128i)m14)));
+++ m14 = ((__m128i)_mm_min_epu8(((__m128i)_mm_srli_epi64(m14, 16)),
+++ ((__m128i)m14)));
+++ m14 = ((__m128i)_mm_min_epu8(((__m128i)_mm_srli_epi64(m14, 8)),
+++ ((__m128i)m14)));
+++ m14 = _mm_unpacklo_epi8(m14, m14);
+++ m14 = _mm_shufflelo_epi16(m14, _MM_SHUFFLE(0, 0, 0, 0));
+++ m13 = _mm_unpacklo_epi64(m14, m14);
+++ ((__m128i*)X)[0] = _mm_subs_epu8(((__m128i*)X)[0], m13);
+++ ((__m128i*)X)[1] = _mm_subs_epu8(((__m128i*)X)[1], m13);
+++ ((__m128i*)X)[2] = _mm_subs_epu8(((__m128i*)X)[2], m13);
+++ ((__m128i*)X)[3] = _mm_subs_epu8(((__m128i*)X)[3], m13);
+++ }
++ }
++- }
++-
++- renormalize(X, 210);
++
++- /*int ch;
++- for(ch = 0; ch < 64; ch++) {
++- printf("%d,", X[ch]);
++- }
++- printf("\n");*/
++-
++- unsigned int j;
++- for(j=0; j < (framebits + excess) % 2; ++j) {
++- int i;
++- for(i=0;i<64/2;i++){
++- BFLY(i, (((framebits+excess) >> 1) << 1) + j , syms, Y, X, (decision_t *)dec, Branchtab);
++- }
+++ renormalize(X, 210);
++
++-
++- renormalize(Y, 210);
++-
++- /*printf("\n");
+++ /*int ch;
++ for(ch = 0; ch < 64; ch++) {
++- printf("%d,", Y[ch]);
+++ printf("%d,", X[ch]);
++ }
++ printf("\n");*/
++
++- }
++- /*skip*/
+++ unsigned int j;
+++ for (j = 0; j < (framebits + excess) % 2; ++j) {
+++ int i;
+++ for (i = 0; i < 64 / 2; i++) {
+++ BFLY(i,
+++ (((framebits + excess) >> 1) << 1) + j,
+++ syms,
+++ Y,
+++ X,
+++ (decision_t*)dec,
+++ Branchtab);
+++ }
+++
+++
+++ renormalize(Y, 210);
+++
+++ /*printf("\n");
+++ for(ch = 0; ch < 64; ch++) {
+++ printf("%d,", Y[ch]);
+++ }
+++ printf("\n");*/
+++ }
+++ /*skip*/
++ }
++
++ #endif /*LV_HAVE_SSE3*/
++@@ -612,30 +633,32 @@ volk_8u_x4_conv_k7_r2_8u_spiral(unsigned char* Y, unsigned char* X,
++
++ #if LV_HAVE_GENERIC
++
++-static inline void
++-volk_8u_x4_conv_k7_r2_8u_generic(unsigned char* Y, unsigned char* X,
++- unsigned char* syms, unsigned char* dec,
++- unsigned int framebits, unsigned int excess,
++- unsigned char* Branchtab)
+++static inline void volk_8u_x4_conv_k7_r2_8u_generic(unsigned char* Y,
+++ unsigned char* X,
+++ unsigned char* syms,
+++ unsigned char* dec,
+++ unsigned int framebits,
+++ unsigned int excess,
+++ unsigned char* Branchtab)
++ {
++- int nbits = framebits + excess;
++- int NUMSTATES = 64;
++- int RENORMALIZE_THRESHOLD = 210;
++-
++- int s,i;
++- for (s=0;s<nbits;s++){
++- void *tmp;
++- for(i=0;i<NUMSTATES/2;i++){
++- BFLY(i, s, syms, Y, X, (decision_t *)dec, Branchtab);
+++ int nbits = framebits + excess;
+++ int NUMSTATES = 64;
+++ int RENORMALIZE_THRESHOLD = 210;
+++
+++ int s, i;
+++ for (s = 0; s < nbits; s++) {
+++ void* tmp;
+++ for (i = 0; i < NUMSTATES / 2; i++) {
+++ BFLY(i, s, syms, Y, X, (decision_t*)dec, Branchtab);
+++ }
+++
+++ renormalize(Y, RENORMALIZE_THRESHOLD);
+++
+++ /// Swap pointers to old and new metrics
+++ tmp = (void*)X;
+++ X = Y;
+++ Y = (unsigned char*)tmp;
++ }
++-
++- renormalize(Y, RENORMALIZE_THRESHOLD);
++-
++- /// Swap pointers to old and new metrics
++- tmp = (void *)X;
++- X = Y;
++- Y = (unsigned char*)tmp;
++- }
++ }
++
++ #endif /* LV_HAVE_GENERIC */
++diff --git a/lib/kernel_tests.h b/lib/kernel_tests.h
++index 8552488..51be069 100644
++--- a/lib/kernel_tests.h
+++++ b/lib/kernel_tests.h
++@@ -8,13 +8,18 @@
++
++ // for puppets we need to get all the func_variants for the puppet and just
++ // keep track of the actual function name to write to results
++-#define VOLK_INIT_PUPP(func, puppet_master_func, test_params)\
++- volk_test_case_t(func##_get_func_desc(), (void(*)())func##_manual, std::string(#func),\
++- std::string(#puppet_master_func), test_params)
+++#define VOLK_INIT_PUPP(func, puppet_master_func, test_params) \
+++ volk_test_case_t(func##_get_func_desc(), \
+++ (void (*)())func##_manual, \
+++ std::string(#func), \
+++ std::string(#puppet_master_func), \
+++ test_params)
++
++-#define VOLK_INIT_TEST(func, test_params)\
++- volk_test_case_t(func##_get_func_desc(), (void(*)())func##_manual, std::string(#func),\
++- test_params)
+++#define VOLK_INIT_TEST(func, test_params) \
+++ volk_test_case_t(func##_get_func_desc(), \
+++ (void (*)())func##_manual, \
+++ std::string(#func), \
+++ test_params)
++
++ #define QA(test) test_cases.push_back(test);
++ std::vector<volk_test_case_t> init_test_list(volk_test_params_t test_params)
++@@ -32,127 +37,135 @@ std::vector<volk_test_case_t> init_test_list(volk_test_params_t test_params)
++ test_params_rotator.set_tol(1e-3);
++
++ std::vector<volk_test_case_t> test_cases;
++- QA(VOLK_INIT_PUPP(volk_64u_popcntpuppet_64u, volk_64u_popcnt, test_params))
++- QA(VOLK_INIT_PUPP(volk_64u_popcntpuppet_64u, volk_64u_popcnt, test_params))
++- QA(VOLK_INIT_PUPP(volk_64u_popcntpuppet_64u, volk_64u_popcnt, test_params))
+++ QA(VOLK_INIT_PUPP(volk_64u_popcntpuppet_64u, volk_64u_popcnt, test_params))
+++ QA(VOLK_INIT_PUPP(volk_64u_popcntpuppet_64u, volk_64u_popcnt, test_params))
+++ QA(VOLK_INIT_PUPP(volk_64u_popcntpuppet_64u, volk_64u_popcnt, test_params))
++ QA(VOLK_INIT_PUPP(volk_16u_byteswappuppet_16u, volk_16u_byteswap, test_params))
++ QA(VOLK_INIT_PUPP(volk_32u_byteswappuppet_32u, volk_32u_byteswap, test_params))
++- QA(VOLK_INIT_PUPP(volk_32u_popcntpuppet_32u, volk_32u_popcnt_32u, test_params))
+++ QA(VOLK_INIT_PUPP(volk_32u_popcntpuppet_32u, volk_32u_popcnt_32u, test_params))
++ QA(VOLK_INIT_PUPP(volk_64u_byteswappuppet_64u, volk_64u_byteswap, test_params))
++- QA(VOLK_INIT_PUPP(volk_32fc_s32fc_rotatorpuppet_32fc, volk_32fc_s32fc_x2_rotator_32fc, test_params_rotator))
++- QA(VOLK_INIT_PUPP(volk_8u_conv_k7_r2puppet_8u, volk_8u_x4_conv_k7_r2_8u, test_params.make_tol(0)))
++- QA(VOLK_INIT_PUPP(volk_32f_x2_fm_detectpuppet_32f, volk_32f_s32f_32f_fm_detect_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_16ic_s32f_deinterleave_real_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_16ic_deinterleave_real_8i, test_params))
++- QA(VOLK_INIT_TEST(volk_16ic_deinterleave_16i_x2, test_params))
++- QA(VOLK_INIT_TEST(volk_16ic_s32f_deinterleave_32f_x2, test_params))
++- QA(VOLK_INIT_TEST(volk_16ic_deinterleave_real_16i, test_params))
++- QA(VOLK_INIT_TEST(volk_16ic_magnitude_16i, test_params))
++- QA(VOLK_INIT_TEST(volk_16ic_s32f_magnitude_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_16ic_convert_32fc, test_params))
++- QA(VOLK_INIT_TEST(volk_16ic_x2_multiply_16ic, test_params))
++- QA(VOLK_INIT_TEST(volk_16ic_x2_dot_prod_16ic, test_params))
++- QA(VOLK_INIT_TEST(volk_16i_s32f_convert_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_16i_convert_8i, test_params))
++- QA(VOLK_INIT_TEST(volk_16i_32fc_dot_prod_32fc, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32f_accumulator_s32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32f_x2_add_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_index_max_16u, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_index_max_32u, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_32f_multiply_32fc, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_32f_add_32fc, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_log2_32f, test_params.make_absolute(1e-5)))
++- QA(VOLK_INIT_TEST(volk_32f_expfast_32f, test_params_inacc_tenth))
++- QA(VOLK_INIT_TEST(volk_32f_x2_pow_32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32f_sin_32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32f_cos_32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32f_tan_32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32f_atan_32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32f_asin_32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32f_acos_32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32fc_s32f_power_32fc, test_params_power))
++- QA(VOLK_INIT_TEST(volk_32f_s32f_calc_spectral_noise_floor_32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32fc_s32f_atan2_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_x2_conjugate_dot_prod_32fc, test_params_inacc_tenth))
++- QA(VOLK_INIT_TEST(volk_32fc_deinterleave_32f_x2, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_deinterleave_64f_x2, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_s32f_deinterleave_real_16i, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_deinterleave_imag_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_deinterleave_real_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_deinterleave_real_64f, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_x2_dot_prod_32fc, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32fc_32f_dot_prod_32fc, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32fc_index_max_16u, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_index_max_32u, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_s32f_magnitude_16i, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_magnitude_32f, test_params_inacc_tenth))
++- QA(VOLK_INIT_TEST(volk_32fc_magnitude_squared_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_x2_add_32fc, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_x2_multiply_32fc, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_x2_multiply_conjugate_32fc, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_x2_divide_32fc, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_conjugate_32fc, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_s32f_convert_16i, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_s32f_convert_32i, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_convert_64f, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_s32f_convert_8i, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_convert_16ic, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_s32f_power_spectrum_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_x2_square_dist_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_x2_s32f_square_dist_scalar_mult_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_x2_divide_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_x2_dot_prod_32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32f_x2_s32f_interleave_16ic, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_x2_interleave_32fc, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_x2_max_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_x2_min_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_x2_multiply_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_64f_multiply_64f, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_64f_add_64f, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_s32f_normalize, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_s32f_power_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_sqrt_32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32f_s32f_stddev_32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32f_stddev_and_mean_32f_x2, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32f_x2_subtract_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_x3_sum_of_poly_32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32i_x2_and_32i, test_params))
++- QA(VOLK_INIT_TEST(volk_32i_s32f_convert_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32i_x2_or_32i, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_x2_dot_prod_16i, test_params))
++- QA(VOLK_INIT_TEST(volk_64f_convert_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_64f_x2_max_64f, test_params))
++- QA(VOLK_INIT_TEST(volk_64f_x2_min_64f, test_params))
++- QA(VOLK_INIT_TEST(volk_64f_x2_multiply_64f, test_params))
++- QA(VOLK_INIT_TEST(volk_64f_x2_add_64f, test_params))
++- QA(VOLK_INIT_TEST(volk_8ic_deinterleave_16i_x2, test_params))
++- QA(VOLK_INIT_TEST(volk_8ic_s32f_deinterleave_32f_x2, test_params))
++- QA(VOLK_INIT_TEST(volk_8ic_deinterleave_real_16i, test_params))
++- QA(VOLK_INIT_TEST(volk_8ic_s32f_deinterleave_real_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_8ic_deinterleave_real_8i, test_params))
++- QA(VOLK_INIT_TEST(volk_8ic_x2_multiply_conjugate_16ic, test_params))
++- QA(VOLK_INIT_TEST(volk_8ic_x2_s32f_multiply_conjugate_32fc, test_params))
++- QA(VOLK_INIT_TEST(volk_8i_convert_16i, test_params))
++- QA(VOLK_INIT_TEST(volk_8i_s32f_convert_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32fc_s32fc_multiply_32fc, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_s32f_multiply_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_binary_slicer_32i, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_binary_slicer_8i, test_params))
++- QA(VOLK_INIT_TEST(volk_32u_reverse_32u, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_tanh_32f, test_params_inacc))
++- QA(VOLK_INIT_TEST(volk_32f_s32f_mod_rangepuppet_32f, test_params))
+++ QA(VOLK_INIT_PUPP(volk_32fc_s32fc_rotatorpuppet_32fc,
+++ volk_32fc_s32fc_x2_rotator_32fc,
+++ test_params_rotator))
+++ QA(VOLK_INIT_PUPP(
+++ volk_8u_conv_k7_r2puppet_8u, volk_8u_x4_conv_k7_r2_8u, test_params.make_tol(0)))
+++ QA(VOLK_INIT_PUPP(
+++ volk_32f_x2_fm_detectpuppet_32f, volk_32f_s32f_32f_fm_detect_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_16ic_s32f_deinterleave_real_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_16ic_deinterleave_real_8i, test_params))
+++ QA(VOLK_INIT_TEST(volk_16ic_deinterleave_16i_x2, test_params))
+++ QA(VOLK_INIT_TEST(volk_16ic_s32f_deinterleave_32f_x2, test_params))
+++ QA(VOLK_INIT_TEST(volk_16ic_deinterleave_real_16i, test_params))
+++ QA(VOLK_INIT_TEST(volk_16ic_magnitude_16i, test_params))
+++ QA(VOLK_INIT_TEST(volk_16ic_s32f_magnitude_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_16ic_convert_32fc, test_params))
+++ QA(VOLK_INIT_TEST(volk_16ic_x2_multiply_16ic, test_params))
+++ QA(VOLK_INIT_TEST(volk_16ic_x2_dot_prod_16ic, test_params))
+++ QA(VOLK_INIT_TEST(volk_16i_s32f_convert_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_16i_convert_8i, test_params))
+++ QA(VOLK_INIT_TEST(volk_16i_32fc_dot_prod_32fc, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32f_accumulator_s32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32f_x2_add_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_index_max_16u, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_index_max_32u, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_32f_multiply_32fc, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_32f_add_32fc, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_log2_32f, test_params.make_absolute(1e-5)))
+++ QA(VOLK_INIT_TEST(volk_32f_expfast_32f, test_params_inacc_tenth))
+++ QA(VOLK_INIT_TEST(volk_32f_x2_pow_32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32f_sin_32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32f_cos_32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32f_tan_32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32f_atan_32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32f_asin_32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32f_acos_32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32fc_s32f_power_32fc, test_params_power))
+++ QA(VOLK_INIT_TEST(volk_32f_s32f_calc_spectral_noise_floor_32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32fc_s32f_atan2_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_x2_conjugate_dot_prod_32fc, test_params_inacc_tenth))
+++ QA(VOLK_INIT_TEST(volk_32fc_deinterleave_32f_x2, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_deinterleave_64f_x2, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_s32f_deinterleave_real_16i, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_deinterleave_imag_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_deinterleave_real_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_deinterleave_real_64f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_x2_dot_prod_32fc, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32fc_32f_dot_prod_32fc, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32fc_index_max_16u, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_index_max_32u, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_s32f_magnitude_16i, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_magnitude_32f, test_params_inacc_tenth))
+++ QA(VOLK_INIT_TEST(volk_32fc_magnitude_squared_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_x2_add_32fc, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_x2_multiply_32fc, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_x2_multiply_conjugate_32fc, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_x2_divide_32fc, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_conjugate_32fc, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_s32f_convert_16i, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_s32f_convert_32i, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_convert_64f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_s32f_convert_8i, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_convert_16ic, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_s32f_power_spectrum_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_x2_square_dist_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_x2_s32f_square_dist_scalar_mult_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_x2_divide_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_x2_dot_prod_32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32f_x2_s32f_interleave_16ic, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_x2_interleave_32fc, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_x2_max_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_x2_min_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_x2_multiply_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_64f_multiply_64f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_64f_add_64f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_s32f_normalize, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_s32f_power_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_sqrt_32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32f_s32f_stddev_32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32f_stddev_and_mean_32f_x2, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32f_x2_subtract_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_x3_sum_of_poly_32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32i_x2_and_32i, test_params))
+++ QA(VOLK_INIT_TEST(volk_32i_s32f_convert_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32i_x2_or_32i, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_x2_dot_prod_16i, test_params))
+++ QA(VOLK_INIT_TEST(volk_64f_convert_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_64f_x2_max_64f, test_params))
+++ QA(VOLK_INIT_TEST(volk_64f_x2_min_64f, test_params))
+++ QA(VOLK_INIT_TEST(volk_64f_x2_multiply_64f, test_params))
+++ QA(VOLK_INIT_TEST(volk_64f_x2_add_64f, test_params))
+++ QA(VOLK_INIT_TEST(volk_8ic_deinterleave_16i_x2, test_params))
+++ QA(VOLK_INIT_TEST(volk_8ic_s32f_deinterleave_32f_x2, test_params))
+++ QA(VOLK_INIT_TEST(volk_8ic_deinterleave_real_16i, test_params))
+++ QA(VOLK_INIT_TEST(volk_8ic_s32f_deinterleave_real_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_8ic_deinterleave_real_8i, test_params))
+++ QA(VOLK_INIT_TEST(volk_8ic_x2_multiply_conjugate_16ic, test_params))
+++ QA(VOLK_INIT_TEST(volk_8ic_x2_s32f_multiply_conjugate_32fc, test_params))
+++ QA(VOLK_INIT_TEST(volk_8i_convert_16i, test_params))
+++ QA(VOLK_INIT_TEST(volk_8i_s32f_convert_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32fc_s32fc_multiply_32fc, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_s32f_multiply_32f, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_binary_slicer_32i, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_binary_slicer_8i, test_params))
+++ QA(VOLK_INIT_TEST(volk_32u_reverse_32u, test_params))
+++ QA(VOLK_INIT_TEST(volk_32f_tanh_32f, test_params_inacc))
+++ QA(VOLK_INIT_TEST(volk_32f_s32f_mod_rangepuppet_32f, test_params))
++ QA(VOLK_INIT_TEST(volk_32fc_x2_s32fc_multiply_conjugate_add_32fc, test_params))
++- QA(VOLK_INIT_PUPP(volk_8u_x3_encodepolarpuppet_8u, volk_8u_x3_encodepolar_8u_x2, test_params))
++- QA(VOLK_INIT_PUPP(volk_32f_8u_polarbutterflypuppet_32f, volk_32f_8u_polarbutterfly_32f, test_params))
++- QA(VOLK_INIT_TEST(volk_32f_exp_32f, test_params))
++-
+++ QA(VOLK_INIT_PUPP(
+++ volk_8u_x3_encodepolarpuppet_8u, volk_8u_x3_encodepolar_8u_x2, test_params))
+++ QA(VOLK_INIT_PUPP(volk_32f_8u_polarbutterflypuppet_32f,
+++ volk_32f_8u_polarbutterfly_32f,
+++ test_params))
++ // no one uses these, so don't test them
++- //VOLK_PROFILE(volk_16i_x5_add_quad_16i_x4, 1e-4, 2046, 10000, &results, benchmark_mode, kernel_regex);
++- //VOLK_PROFILE(volk_16i_branch_4_state_8, 1e-4, 2046, 10000, &results, benchmark_mode, kernel_regex);
++- //VOLK_PROFILE(volk_16i_max_star_16i, 0, 0, 204602, 10000, &results, benchmark_mode, kernel_regex);
++- //VOLK_PROFILE(volk_16i_max_star_horizontal_16i, 0, 0, 204602, 10000, &results, benchmark_mode, kernel_regex);
++- //VOLK_PROFILE(volk_16i_permute_and_scalar_add, 1e-4, 0, 2046, 10000, &results, benchmark_mode, kernel_regex);
++- //VOLK_PROFILE(volk_16i_x4_quad_max_star_16i, 1e-4, 0, 2046, 10000, &results, benchmark_mode, kernel_regex);
+++ // VOLK_PROFILE(volk_16i_x5_add_quad_16i_x4, 1e-4, 2046, 10000, &results,
+++ // benchmark_mode, kernel_regex); VOLK_PROFILE(volk_16i_branch_4_state_8, 1e-4, 2046,
+++ // 10000, &results, benchmark_mode, kernel_regex); VOLK_PROFILE(volk_16i_max_star_16i,
+++ // 0, 0, 204602, 10000, &results, benchmark_mode, kernel_regex);
+++ // VOLK_PROFILE(volk_16i_max_star_horizontal_16i, 0, 0, 204602, 10000, &results,
+++ // benchmark_mode, kernel_regex); VOLK_PROFILE(volk_16i_permute_and_scalar_add, 1e-4,
+++ // 0, 2046, 10000, &results, benchmark_mode, kernel_regex);
+++ // VOLK_PROFILE(volk_16i_x4_quad_max_star_16i, 1e-4, 0, 2046, 10000, &results,
+++ // benchmark_mode, kernel_regex);
++ // we need a puppet for this one
++ //(VOLK_INIT_TEST(volk_32fc_s32f_x2_power_spectral_density_32f, test_params))
++
++diff --git a/lib/qa_utils.cc b/lib/qa_utils.cc
++index 76df069..1dcee6e 100644
++--- a/lib/qa_utils.cc
+++++ b/lib/qa_utils.cc
++@@ -1,79 +1,94 @@
++-#include <volk/volk.h>
++ #include "qa_utils.h"
+++#include <volk/volk.h>
++
++-#include <volk/volk.h> // for volk_func_desc_t
++-#include <volk/volk_malloc.h> // for volk_free, volk_m...
+++#include <volk/volk.h> // for volk_func_desc_t
+++#include <volk/volk_malloc.h> // for volk_free, volk_m...
++
++-#include <assert.h> // for assert
++-#include <stdint.h> // for uint16_t, uint64_t
++-#include <sys/time.h> // for CLOCKS_PER_SEC
++-#include <sys/types.h> // for int16_t, int32_t
+++#include <assert.h> // for assert
+++#include <stdint.h> // for uint16_t, uint64_t
+++#include <sys/time.h> // for CLOCKS_PER_SEC
+++#include <sys/types.h> // for int16_t, int32_t
++ #include <chrono>
++-#include <cmath> // for sqrt, fabs, abs
++-#include <cstring> // for memcpy, memset
++-#include <ctime> // for clock
++-#include <fstream> // for operator<<, basic...
++-#include <iostream> // for cout, cerr
++-#include <limits> // for numeric_limits
++-#include <map> // for map, map<>::mappe...
+++#include <cmath> // for sqrt, fabs, abs
+++#include <cstring> // for memcpy, memset
+++#include <ctime> // for clock
+++#include <fstream> // for operator<<, basic...
+++#include <iostream> // for cout, cerr
+++#include <limits> // for numeric_limits
+++#include <map> // for map, map<>::mappe...
++ #include <random>
++-#include <vector> // for vector, _Bit_refe...
+++#include <vector> // for vector, _Bit_refe...
++
++ template <typename T>
++-void random_floats(void *buf, unsigned int n, std::default_random_engine& rnd_engine)
+++void random_floats(void* buf, unsigned int n, std::default_random_engine& rnd_engine)
++ {
++- T *array = static_cast<T*>(buf);
+++ T* array = static_cast<T*>(buf);
++ std::uniform_real_distribution<T> uniform_dist(T(-1), T(1));
++- for(unsigned int i = 0; i < n; i++) {
+++ for (unsigned int i = 0; i < n; i++) {
++ array[i] = uniform_dist(rnd_engine);
++ }
++ }
++
++-void load_random_data(void *data, volk_type_t type, unsigned int n) {
+++void load_random_data(void* data, volk_type_t type, unsigned int n)
+++{
++ std::random_device rnd_device;
++ std::default_random_engine rnd_engine(rnd_device());
++- if(type.is_complex) n *= 2;
++- if(type.is_float) {
++- if(type.size == 8) {
+++ if (type.is_complex)
+++ n *= 2;
+++ if (type.is_float) {
+++ if (type.size == 8) {
++ random_floats<double>(data, n, rnd_engine);
++ } else {
++- random_floats<float> (data, n, rnd_engine);
+++ random_floats<float>(data, n, rnd_engine);
++ }
++ } else {
++- float int_max = float(uint64_t(2) << (type.size*8));
++- if(type.is_signed) int_max /= 2.0;
+++ float int_max = float(uint64_t(2) << (type.size * 8));
+++ if (type.is_signed)
+++ int_max /= 2.0;
++ std::uniform_real_distribution<float> uniform_dist(-int_max, int_max);
++- for(unsigned int i=0; i<n; i++) {
+++ for (unsigned int i = 0; i < n; i++) {
++ float scaled_rand = uniform_dist(rnd_engine);
++- //man i really don't know how to do this in a more clever way, you have to cast down at some point
++- switch(type.size) {
+++ // man i really don't know how to do this in a more clever way, you have to
+++ // cast down at some point
+++ switch (type.size) {
++ case 8:
++- if(type.is_signed) ((int64_t *)data)[i] = (int64_t) scaled_rand;
++- else ((uint64_t *)data)[i] = (uint64_t) scaled_rand;
++- break;
+++ if (type.is_signed)
+++ ((int64_t*)data)[i] = (int64_t)scaled_rand;
+++ else
+++ ((uint64_t*)data)[i] = (uint64_t)scaled_rand;
+++ break;
++ case 4:
++- if(type.is_signed) ((int32_t *)data)[i] = (int32_t) scaled_rand;
++- else ((uint32_t *)data)[i] = (uint32_t) scaled_rand;
++- break;
+++ if (type.is_signed)
+++ ((int32_t*)data)[i] = (int32_t)scaled_rand;
+++ else
+++ ((uint32_t*)data)[i] = (uint32_t)scaled_rand;
+++ break;
++ case 2:
++- if(type.is_signed) ((int16_t *)data)[i] = (int16_t)((int16_t) scaled_rand % 8);
++- else ((uint16_t *)data)[i] = (uint16_t) ((int16_t) scaled_rand % 8);
++- break;
+++ if (type.is_signed)
+++ ((int16_t*)data)[i] = (int16_t)((int16_t)scaled_rand % 8);
+++ else
+++ ((uint16_t*)data)[i] = (uint16_t)((int16_t)scaled_rand % 8);
+++ break;
++ case 1:
++- if(type.is_signed) ((int8_t *)data)[i] = (int8_t) scaled_rand;
++- else ((uint8_t *)data)[i] = (uint8_t) scaled_rand;
++- break;
+++ if (type.is_signed)
+++ ((int8_t*)data)[i] = (int8_t)scaled_rand;
+++ else
+++ ((uint8_t*)data)[i] = (uint8_t)scaled_rand;
+++ break;
++ default:
++- throw "load_random_data: no support for data size > 8 or < 1"; //no shenanigans here
+++ throw "load_random_data: no support for data size > 8 or < 1"; // no
+++ // shenanigans
+++ // here
++ }
++ }
++ }
++ }
++
++-static std::vector<std::string> get_arch_list(volk_func_desc_t desc) {
+++static std::vector<std::string> get_arch_list(volk_func_desc_t desc)
+++{
++ std::vector<std::string> archlist;
++
++- for(size_t i = 0; i < desc.n_impls; i++) {
+++ for (size_t i = 0; i < desc.n_impls; i++) {
++ archlist.push_back(std::string(desc.impl_names[i]));
++ }
++
++@@ -96,7 +111,8 @@ T volk_lexical_cast(const std::string& str)
++ return var;
++ }
++
++-volk_type_t volk_type_from_string(std::string name) {
+++volk_type_t volk_type_from_string(std::string name)
+++{
++ volk_type_t type;
++ type.is_float = false;
++ type.is_scalar = false;
++@@ -105,28 +121,28 @@ volk_type_t volk_type_from_string(std::string name) {
++ type.size = 0;
++ type.str = name;
++
++- if(name.size() < 2) {
+++ if (name.size() < 2) {
++ throw std::string("name too short to be a datatype");
++ }
++
++- //is it a scalar?
++- if(name[0] == 's') {
+++ // is it a scalar?
+++ if (name[0] == 's') {
++ type.is_scalar = true;
++- name = name.substr(1, name.size()-1);
+++ name = name.substr(1, name.size() - 1);
++ }
++
++- //get the data size
+++ // get the data size
++ size_t last_size_pos = name.find_last_of("0123456789");
++- if(last_size_pos == std::string::npos) {
+++ if (last_size_pos == std::string::npos) {
++ throw std::string("no size spec in type ").append(name);
++ }
++- //will throw if malformed
++- int size = volk_lexical_cast<int>(name.substr(0, last_size_pos+1));
+++ // will throw if malformed
+++ int size = volk_lexical_cast<int>(name.substr(0, last_size_pos + 1));
++
++ assert(((size % 8) == 0) && (size <= 64) && (size != 0));
++- type.size = size/8; //in bytes
+++ type.size = size / 8; // in bytes
++
++- for(size_t i=last_size_pos+1; i < name.size(); i++) {
+++ for (size_t i = last_size_pos + 1; i < name.size(); i++) {
++ switch (name[i]) {
++ case 'f':
++ type.is_float = true;
++@@ -148,7 +164,8 @@ volk_type_t volk_type_from_string(std::string name) {
++ return type;
++ }
++
++-std::vector<std::string> split_signature(const std::string &protokernel_signature) {
+++std::vector<std::string> split_signature(const std::string& protokernel_signature)
+++{
++ std::vector<std::string> signature_tokens;
++ std::string token;
++ for (unsigned int loc = 0; loc < protokernel_signature.size(); ++loc) {
++@@ -165,16 +182,17 @@ std::vector<std::string> split_signature(const std::string &protokernel_signatur
++ return signature_tokens;
++ }
++
++-static void get_signatures_from_name(std::vector<volk_type_t> &inputsig,
++- std::vector<volk_type_t> &outputsig,
++- std::string name) {
+++static void get_signatures_from_name(std::vector<volk_type_t>& inputsig,
+++ std::vector<volk_type_t>& outputsig,
+++ std::string name)
+++{
++
++ std::vector<std::string> toked = split_signature(name);
++
++ assert(toked[0] == "volk");
++ toked.erase(toked.begin());
++
++- //ok. we're assuming a string in the form
+++ // ok. we're assuming a string in the form
++ //(sig)_(multiplier-opt)_..._(name)_(sig)_(multiplier-opt)_..._(alignment)
++
++ enum { SIDE_INPUT, SIDE_NAME, SIDE_OUTPUT } side = SIDE_INPUT;
++@@ -184,106 +202,184 @@ static void get_signatures_from_name(std::vector<volk_type_t> &inputsig,
++ std::string token = toked[token_index];
++ try {
++ type = volk_type_from_string(token);
++- if(side == SIDE_NAME) side = SIDE_OUTPUT; //if this is the first one after the name...
++-
++- if(side == SIDE_INPUT) inputsig.push_back(type);
++- else outputsig.push_back(type);
++- } catch (...){
++- if(token[0] == 'x' && (token.size() > 1) && (token[1] > '0' && token[1] < '9')) { //it's a multiplier
++- if(side == SIDE_INPUT) assert(inputsig.size() > 0);
++- else assert(outputsig.size() > 0);
++- int multiplier = volk_lexical_cast<int>(token.substr(1, token.size()-1)); //will throw if invalid
++- for(int i=1; i<multiplier; i++) {
++- if(side == SIDE_INPUT) inputsig.push_back(inputsig.back());
++- else outputsig.push_back(outputsig.back());
+++ if (side == SIDE_NAME)
+++ side = SIDE_OUTPUT; // if this is the first one after the name...
+++
+++ if (side == SIDE_INPUT)
+++ inputsig.push_back(type);
+++ else
+++ outputsig.push_back(type);
+++ } catch (...) {
+++ if (token[0] == 'x' && (token.size() > 1) &&
+++ (token[1] > '0' && token[1] < '9')) { // it's a multiplier
+++ if (side == SIDE_INPUT)
+++ assert(inputsig.size() > 0);
+++ else
+++ assert(outputsig.size() > 0);
+++ int multiplier = volk_lexical_cast<int>(
+++ token.substr(1, token.size() - 1)); // will throw if invalid
+++ for (int i = 1; i < multiplier; i++) {
+++ if (side == SIDE_INPUT)
+++ inputsig.push_back(inputsig.back());
+++ else
+++ outputsig.push_back(outputsig.back());
++ }
++- }
++- else if(side == SIDE_INPUT) { //it's the function name, at least it better be
+++ } else if (side ==
+++ SIDE_INPUT) { // it's the function name, at least it better be
++ side = SIDE_NAME;
++ fn_name.append("_");
++ fn_name.append(token);
++- }
++- else if(side == SIDE_OUTPUT) {
++- if(token != toked.back()) throw; //the last token in the name is the alignment
+++ } else if (side == SIDE_OUTPUT) {
+++ if (token != toked.back())
+++ throw; // the last token in the name is the alignment
++ }
++ }
++ }
++- //we don't need an output signature (some fn's operate on the input data, "in place"), but we do need at least one input!
+++ // we don't need an output signature (some fn's operate on the input data, "in
+++ // place"), but we do need at least one input!
++ assert(inputsig.size() != 0);
++-
++ }
++
++-inline void run_cast_test1(volk_fn_1arg func, std::vector<void *> &buffs, unsigned int vlen, unsigned int iter, std::string arch) {
++- while(iter--) func(buffs[0], vlen, arch.c_str());
+++inline void run_cast_test1(volk_fn_1arg func,
+++ std::vector<void*>& buffs,
+++ unsigned int vlen,
+++ unsigned int iter,
+++ std::string arch)
+++{
+++ while (iter--)
+++ func(buffs[0], vlen, arch.c_str());
++ }
++
++-inline void run_cast_test2(volk_fn_2arg func, std::vector<void *> &buffs, unsigned int vlen, unsigned int iter, std::string arch) {
++- while(iter--) func(buffs[0], buffs[1], vlen, arch.c_str());
+++inline void run_cast_test2(volk_fn_2arg func,
+++ std::vector<void*>& buffs,
+++ unsigned int vlen,
+++ unsigned int iter,
+++ std::string arch)
+++{
+++ while (iter--)
+++ func(buffs[0], buffs[1], vlen, arch.c_str());
++ }
++
++-inline void run_cast_test3(volk_fn_3arg func, std::vector<void *> &buffs, unsigned int vlen, unsigned int iter, std::string arch) {
++- while(iter--) func(buffs[0], buffs[1], buffs[2], vlen, arch.c_str());
+++inline void run_cast_test3(volk_fn_3arg func,
+++ std::vector<void*>& buffs,
+++ unsigned int vlen,
+++ unsigned int iter,
+++ std::string arch)
+++{
+++ while (iter--)
+++ func(buffs[0], buffs[1], buffs[2], vlen, arch.c_str());
++ }
++
++-inline void run_cast_test4(volk_fn_4arg func, std::vector<void *> &buffs, unsigned int vlen, unsigned int iter, std::string arch) {
++- while(iter--) func(buffs[0], buffs[1], buffs[2], buffs[3], vlen, arch.c_str());
+++inline void run_cast_test4(volk_fn_4arg func,
+++ std::vector<void*>& buffs,
+++ unsigned int vlen,
+++ unsigned int iter,
+++ std::string arch)
+++{
+++ while (iter--)
+++ func(buffs[0], buffs[1], buffs[2], buffs[3], vlen, arch.c_str());
++ }
++
++-inline void run_cast_test1_s32f(volk_fn_1arg_s32f func, std::vector<void *> &buffs, float scalar, unsigned int vlen, unsigned int iter, std::string arch) {
++- while(iter--) func(buffs[0], scalar, vlen, arch.c_str());
+++inline void run_cast_test1_s32f(volk_fn_1arg_s32f func,
+++ std::vector<void*>& buffs,
+++ float scalar,
+++ unsigned int vlen,
+++ unsigned int iter,
+++ std::string arch)
+++{
+++ while (iter--)
+++ func(buffs[0], scalar, vlen, arch.c_str());
++ }
++
++-inline void run_cast_test2_s32f(volk_fn_2arg_s32f func, std::vector<void *> &buffs, float scalar, unsigned int vlen, unsigned int iter, std::string arch) {
++- while(iter--) func(buffs[0], buffs[1], scalar, vlen, arch.c_str());
+++inline void run_cast_test2_s32f(volk_fn_2arg_s32f func,
+++ std::vector<void*>& buffs,
+++ float scalar,
+++ unsigned int vlen,
+++ unsigned int iter,
+++ std::string arch)
+++{
+++ while (iter--)
+++ func(buffs[0], buffs[1], scalar, vlen, arch.c_str());
++ }
++
++-inline void run_cast_test3_s32f(volk_fn_3arg_s32f func, std::vector<void *> &buffs, float scalar, unsigned int vlen, unsigned int iter, std::string arch) {
++- while(iter--) func(buffs[0], buffs[1], buffs[2], scalar, vlen, arch.c_str());
+++inline void run_cast_test3_s32f(volk_fn_3arg_s32f func,
+++ std::vector<void*>& buffs,
+++ float scalar,
+++ unsigned int vlen,
+++ unsigned int iter,
+++ std::string arch)
+++{
+++ while (iter--)
+++ func(buffs[0], buffs[1], buffs[2], scalar, vlen, arch.c_str());
++ }
++
++-inline void run_cast_test1_s32fc(volk_fn_1arg_s32fc func, std::vector<void *> &buffs, lv_32fc_t scalar, unsigned int vlen, unsigned int iter, std::string arch) {
++- while(iter--) func(buffs[0], scalar, vlen, arch.c_str());
+++inline void run_cast_test1_s32fc(volk_fn_1arg_s32fc func,
+++ std::vector<void*>& buffs,
+++ lv_32fc_t scalar,
+++ unsigned int vlen,
+++ unsigned int iter,
+++ std::string arch)
+++{
+++ while (iter--)
+++ func(buffs[0], scalar, vlen, arch.c_str());
++ }
++
++-inline void run_cast_test2_s32fc(volk_fn_2arg_s32fc func, std::vector<void *> &buffs, lv_32fc_t scalar, unsigned int vlen, unsigned int iter, std::string arch) {
++- while(iter--) func(buffs[0], buffs[1], scalar, vlen, arch.c_str());
+++inline void run_cast_test2_s32fc(volk_fn_2arg_s32fc func,
+++ std::vector<void*>& buffs,
+++ lv_32fc_t scalar,
+++ unsigned int vlen,
+++ unsigned int iter,
+++ std::string arch)
+++{
+++ while (iter--)
+++ func(buffs[0], buffs[1], scalar, vlen, arch.c_str());
++ }
++
++-inline void run_cast_test3_s32fc(volk_fn_3arg_s32fc func, std::vector<void *> &buffs, lv_32fc_t scalar, unsigned int vlen, unsigned int iter, std::string arch) {
++- while(iter--) func(buffs[0], buffs[1], buffs[2], scalar, vlen, arch.c_str());
+++inline void run_cast_test3_s32fc(volk_fn_3arg_s32fc func,
+++ std::vector<void*>& buffs,
+++ lv_32fc_t scalar,
+++ unsigned int vlen,
+++ unsigned int iter,
+++ std::string arch)
+++{
+++ while (iter--)
+++ func(buffs[0], buffs[1], buffs[2], scalar, vlen, arch.c_str());
++ }
++
++ template <class t>
++-bool fcompare(t *in1, t *in2, unsigned int vlen, float tol, bool absolute_mode) {
+++bool fcompare(t* in1, t* in2, unsigned int vlen, float tol, bool absolute_mode)
+++{
++ bool fail = false;
++ int print_max_errs = 10;
++- for(unsigned int i=0; i<vlen; i++) {
+++ for (unsigned int i = 0; i < vlen; i++) {
++ if (absolute_mode) {
++- if (fabs(((t *)(in1))[i] - ((t *)(in2))[i]) > tol) {
++- fail=true;
++- if(print_max_errs-- > 0) {
++- std::cout << "offset " << i << " in1: " << t(((t *)(in1))[i]) << " in2: " << t(((t *)(in2))[i]);
+++ if (fabs(((t*)(in1))[i] - ((t*)(in2))[i]) > tol) {
+++ fail = true;
+++ if (print_max_errs-- > 0) {
+++ std::cout << "offset " << i << " in1: " << t(((t*)(in1))[i])
+++ << " in2: " << t(((t*)(in2))[i]);
++ std::cout << " tolerance was: " << tol << std::endl;
++ }
++ }
++ } else {
++ // for very small numbers we'll see round off errors due to limited
++ // precision. So a special test case...
++- if(fabs(((t *)(in1))[i]) < 1e-30) {
++- if( fabs( ((t *)(in2))[i] ) > tol )
++- {
++- fail=true;
++- if(print_max_errs-- > 0) {
++- std::cout << "offset " << i << " in1: " << t(((t *)(in1))[i]) << " in2: " << t(((t *)(in2))[i]);
+++ if (fabs(((t*)(in1))[i]) < 1e-30) {
+++ if (fabs(((t*)(in2))[i]) > tol) {
+++ fail = true;
+++ if (print_max_errs-- > 0) {
+++ std::cout << "offset " << i << " in1: " << t(((t*)(in1))[i])
+++ << " in2: " << t(((t*)(in2))[i]);
++ std::cout << " tolerance was: " << tol << std::endl;
++ }
++ }
++ }
++ // the primary test is the percent different greater than given tol
++- else if(fabs(((t *)(in1))[i] - ((t *)(in2))[i])/fabs(((t *)in1)[i]) > tol) {
++- fail=true;
++- if(print_max_errs-- > 0) {
++- std::cout << "offset " << i << " in1: " << t(((t *)(in1))[i]) << " in2: " << t(((t *)(in2))[i]);
+++ else if (fabs(((t*)(in1))[i] - ((t*)(in2))[i]) / fabs(((t*)in1)[i]) > tol) {
+++ fail = true;
+++ if (print_max_errs-- > 0) {
+++ std::cout << "offset " << i << " in1: " << t(((t*)(in1))[i])
+++ << " in2: " << t(((t*)(in2))[i]);
++ std::cout << " tolerance was: " << tol << std::endl;
++ }
++ }
++@@ -294,43 +390,50 @@ bool fcompare(t *in1, t *in2, unsigned int vlen, float tol, bool absolute_mode)
++ }
++
++ template <class t>
++-bool ccompare(t *in1, t *in2, unsigned int vlen, float tol, bool absolute_mode) {
+++bool ccompare(t* in1, t* in2, unsigned int vlen, float tol, bool absolute_mode)
+++{
++ if (absolute_mode) {
++- std::cout << "ccompare does not support absolute mode" << std::endl;
++- return true;
+++ std::cout << "ccompare does not support absolute mode" << std::endl;
+++ return true;
++ }
++ bool fail = false;
++ int print_max_errs = 10;
++- for(unsigned int i=0; i<2*vlen; i+=2) {
++- if (std::isnan(in1[i]) || std::isnan(in1[i+1]) || std::isnan(in2[i]) || std::isnan(in2[i+1])
++- || std::isinf(in1[i]) || std::isinf(in1[i+1]) || std::isinf(in2[i]) || std::isinf(in2[i+1])) {
++- fail=true;
++- if(print_max_errs-- > 0) {
++- std::cout << "offset " << i/2 << " in1: " << in1[i] << " + " << in1[i+1] << "j in2: " << in2[i] << " + " << in2[i+1] << "j";
+++ for (unsigned int i = 0; i < 2 * vlen; i += 2) {
+++ if (std::isnan(in1[i]) || std::isnan(in1[i + 1]) || std::isnan(in2[i]) ||
+++ std::isnan(in2[i + 1]) || std::isinf(in1[i]) || std::isinf(in1[i + 1]) ||
+++ std::isinf(in2[i]) || std::isinf(in2[i + 1])) {
+++ fail = true;
+++ if (print_max_errs-- > 0) {
+++ std::cout << "offset " << i / 2 << " in1: " << in1[i] << " + "
+++ << in1[i + 1] << "j in2: " << in2[i] << " + " << in2[i + 1]
+++ << "j";
++ std::cout << " tolerance was: " << tol << std::endl;
++ }
++ }
++- t diff[2] = { in1[i] - in2[i], in1[i+1] - in2[i+1] };
++- t err = std::sqrt(diff[0] * diff[0] + diff[1] * diff[1]);
++- t norm = std::sqrt(in1[i] * in1[i] + in1[i+1] * in1[i+1]);
+++ t diff[2] = { in1[i] - in2[i], in1[i + 1] - in2[i + 1] };
+++ t err = std::sqrt(diff[0] * diff[0] + diff[1] * diff[1]);
+++ t norm = std::sqrt(in1[i] * in1[i] + in1[i + 1] * in1[i + 1]);
++
++ // for very small numbers we'll see round off errors due to limited
++ // precision. So a special test case...
++ if (norm < 1e-30) {
++- if (err > tol)
++- {
++- fail=true;
++- if(print_max_errs-- > 0) {
++- std::cout << "offset " << i/2 << " in1: " << in1[i] << " + " << in1[i+1] << "j in2: " << in2[i] << " + " << in2[i+1] << "j";
+++ if (err > tol) {
+++ fail = true;
+++ if (print_max_errs-- > 0) {
+++ std::cout << "offset " << i / 2 << " in1: " << in1[i] << " + "
+++ << in1[i + 1] << "j in2: " << in2[i] << " + " << in2[i + 1]
+++ << "j";
++ std::cout << " tolerance was: " << tol << std::endl;
++ }
++ }
++ }
++ // the primary test is the percent different greater than given tol
++- else if((err / norm) > tol) {
++- fail=true;
++- if(print_max_errs-- > 0) {
++- std::cout << "offset " << i/2 << " in1: " << in1[i] << " + " << in1[i+1] << "j in2: " << in2[i] << " + " << in2[i+1] << "j";
+++ else if ((err / norm) > tol) {
+++ fail = true;
+++ if (print_max_errs-- > 0) {
+++ std::cout << "offset " << i / 2 << " in1: " << in1[i] << " + "
+++ << in1[i + 1] << "j in2: " << in2[i] << " + " << in2[i + 1]
+++ << "j";
++ std::cout << " tolerance was: " << tol << std::endl;
++ }
++ }
++@@ -340,18 +443,21 @@ bool ccompare(t *in1, t *in2, unsigned int vlen, float tol, bool absolute_mode)
++ }
++
++ template <class t>
++-bool icompare(t *in1, t *in2, unsigned int vlen, unsigned int tol, bool absolute_mode) {
+++bool icompare(t* in1, t* in2, unsigned int vlen, unsigned int tol, bool absolute_mode)
+++{
++ if (absolute_mode) {
++- std::cout << "icompare does not support absolute mode" << std::endl;
++- return true;
+++ std::cout << "icompare does not support absolute mode" << std::endl;
+++ return true;
++ }
++ bool fail = false;
++ int print_max_errs = 10;
++- for(unsigned int i=0; i<vlen; i++) {
++- if(((unsigned int)abs(int(((t *)(in1))[i]) - int(((t *)(in2))[i]))) > tol) {
++- fail=true;
++- if(print_max_errs-- > 0) {
++- std::cout << "offset " << i << " in1: " << static_cast<int>(t(((t *)(in1))[i])) << " in2: " << static_cast<int>(t(((t *)(in2))[i]));
+++ for (unsigned int i = 0; i < vlen; i++) {
+++ if (((unsigned int)abs(int(((t*)(in1))[i]) - int(((t*)(in2))[i]))) > tol) {
+++ fail = true;
+++ if (print_max_errs-- > 0) {
+++ std::cout << "offset " << i
+++ << " in1: " << static_cast<int>(t(((t*)(in1))[i]))
+++ << " in2: " << static_cast<int>(t(((t*)(in2))[i]));
++ std::cout << " tolerance was: " << tol << std::endl;
++ }
++ }
++@@ -360,34 +466,46 @@ bool icompare(t *in1, t *in2, unsigned int vlen, unsigned int tol, bool absolute
++ return fail;
++ }
++
++-class volk_qa_aligned_mem_pool{
+++class volk_qa_aligned_mem_pool
+++{
++ public:
++- void *get_new(size_t size){
+++ void* get_new(size_t size)
+++ {
++ size_t alignment = volk_get_alignment();
++ void* ptr = volk_malloc(size, alignment);
++ memset(ptr, 0x00, size);
++ _mems.push_back(ptr);
++ return ptr;
++ }
++- ~volk_qa_aligned_mem_pool() {
++- for(unsigned int ii = 0; ii < _mems.size(); ++ii) {
+++ ~volk_qa_aligned_mem_pool()
+++ {
+++ for (unsigned int ii = 0; ii < _mems.size(); ++ii) {
++ volk_free(_mems[ii]);
++ }
++ }
++-private: std::vector<void * > _mems;
+++
+++private:
+++ std::vector<void*> _mems;
++ };
++
++ bool run_volk_tests(volk_func_desc_t desc,
++ void (*manual_func)(),
++ std::string name,
++ volk_test_params_t test_params,
++- std::vector<volk_test_results_t> *results,
++- std::string puppet_master_name
++-)
+++ std::vector<volk_test_results_t>* results,
+++ std::string puppet_master_name)
++ {
++- return run_volk_tests(desc, manual_func, name, test_params.tol(), test_params.scalar(),
++- test_params.vlen(), test_params.iter(), results, puppet_master_name,
++- test_params.absolute_mode(), test_params.benchmark_mode());
+++ return run_volk_tests(desc,
+++ manual_func,
+++ name,
+++ test_params.tol(),
+++ test_params.scalar(),
+++ test_params.vlen(),
+++ test_params.iter(),
+++ results,
+++ puppet_master_name,
+++ test_params.absolute_mode(),
+++ test_params.benchmark_mode());
++ }
++
++ bool run_volk_tests(volk_func_desc_t desc,
++@@ -397,17 +515,18 @@ bool run_volk_tests(volk_func_desc_t desc,
++ lv_32fc_t scalar,
++ unsigned int vlen,
++ unsigned int iter,
++- std::vector<volk_test_results_t> *results,
+++ std::vector<volk_test_results_t>* results,
++ std::string puppet_master_name,
++ bool absolute_mode,
++- bool benchmark_mode
++-) {
+++ bool benchmark_mode)
+++{
++ // Initialize this entry in results vector
++ results->push_back(volk_test_results_t());
++ results->back().name = name;
++ results->back().vlen = vlen;
++ results->back().iter = iter;
++- std::cout << "RUN_VOLK_TESTS: " << name << "(" << vlen << "," << iter << ")" << std::endl;
+++ std::cout << "RUN_VOLK_TESTS: " << name << "(" << vlen << "," << iter << ")"
+++ << std::endl;
++
++ // vlen_twiddle will increase vlen for malloc and data generation
++ // but kernels will still be called with the user provided vlen.
++@@ -418,57 +537,64 @@ bool run_volk_tests(volk_func_desc_t desc,
++ const float tol_f = tol;
++ const unsigned int tol_i = static_cast<const unsigned int>(tol);
++
++- //first let's get a list of available architectures for the test
+++ // first let's get a list of available architectures for the test
++ std::vector<std::string> arch_list = get_arch_list(desc);
++
++- if((!benchmark_mode) && (arch_list.size() < 2)) {
+++ if ((!benchmark_mode) && (arch_list.size() < 2)) {
++ std::cout << "no architectures to test" << std::endl;
++ return false;
++ }
++
++- //something that can hang onto memory and cleanup when this function exits
+++ // something that can hang onto memory and cleanup when this function exits
++ volk_qa_aligned_mem_pool mem_pool;
++
++- //now we have to get a function signature by parsing the name
+++ // now we have to get a function signature by parsing the name
++ std::vector<volk_type_t> inputsig, outputsig;
++ try {
++ get_signatures_from_name(inputsig, outputsig, name);
++- }
++- catch (std::exception &error) {
++- std::cerr << "Error: unable to get function signature from kernel name" << std::endl;
+++ } catch (std::exception& error) {
+++ std::cerr << "Error: unable to get function signature from kernel name"
+++ << std::endl;
++ std::cerr << " - " << name << std::endl;
++ return false;
++ }
++
++- //pull the input scalars into their own vector
+++ // pull the input scalars into their own vector
++ std::vector<volk_type_t> inputsc;
++- for(size_t i=0; i<inputsig.size(); i++) {
++- if(inputsig[i].is_scalar) {
+++ for (size_t i = 0; i < inputsig.size(); i++) {
+++ if (inputsig[i].is_scalar) {
++ inputsc.push_back(inputsig[i]);
++ inputsig.erase(inputsig.begin() + i);
++ i -= 1;
++ }
++ }
++- std::vector<void *> inbuffs;
++- for (unsigned int inputsig_index = 0; inputsig_index < inputsig.size(); ++ inputsig_index) {
+++ std::vector<void*> inbuffs;
+++ for (unsigned int inputsig_index = 0; inputsig_index < inputsig.size();
+++ ++inputsig_index) {
++ volk_type_t sig = inputsig[inputsig_index];
++- if(!sig.is_scalar) //we don't make buffers for scalars
++- inbuffs.push_back(mem_pool.get_new(vlen*sig.size*(sig.is_complex ? 2 : 1)));
+++ if (!sig.is_scalar) // we don't make buffers for scalars
+++ inbuffs.push_back(
+++ mem_pool.get_new(vlen * sig.size * (sig.is_complex ? 2 : 1)));
++ }
++- for(size_t i=0; i<inbuffs.size(); i++) {
+++ for (size_t i = 0; i < inbuffs.size(); i++) {
++ load_random_data(inbuffs[i], inputsig[i], vlen);
++ }
++
++- //ok let's make a vector of vector of void buffers, which holds the input/output vectors for each arch
++- std::vector<std::vector<void *> > test_data;
++- for(size_t i=0; i<arch_list.size(); i++) {
++- std::vector<void *> arch_buffs;
++- for(size_t j=0; j<outputsig.size(); j++) {
++- arch_buffs.push_back(mem_pool.get_new(vlen*outputsig[j].size*(outputsig[j].is_complex ? 2 : 1)));
+++ // ok let's make a vector of vector of void buffers, which holds the input/output
+++ // vectors for each arch
+++ std::vector<std::vector<void*>> test_data;
+++ for (size_t i = 0; i < arch_list.size(); i++) {
+++ std::vector<void*> arch_buffs;
+++ for (size_t j = 0; j < outputsig.size(); j++) {
+++ arch_buffs.push_back(mem_pool.get_new(vlen * outputsig[j].size *
+++ (outputsig[j].is_complex ? 2 : 1)));
++ }
++- for(size_t j=0; j<inputsig.size(); j++) {
++- void *arch_inbuff = mem_pool.get_new(vlen*inputsig[j].size*(inputsig[j].is_complex ? 2 : 1));
++- memcpy(arch_inbuff, inbuffs[j], vlen * inputsig[j].size * (inputsig[j].is_complex ? 2 : 1));
+++ for (size_t j = 0; j < inputsig.size(); j++) {
+++ void* arch_inbuff = mem_pool.get_new(vlen * inputsig[j].size *
+++ (inputsig[j].is_complex ? 2 : 1));
+++ memcpy(arch_inbuff,
+++ inbuffs[j],
+++ vlen * inputsig[j].size * (inputsig[j].is_complex ? 2 : 1));
++ arch_buffs.push_back(arch_inbuff);
++ }
++ test_data.push_back(arch_buffs);
++@@ -478,53 +604,90 @@ bool run_volk_tests(volk_func_desc_t desc,
++ both_sigs.insert(both_sigs.end(), outputsig.begin(), outputsig.end());
++ both_sigs.insert(both_sigs.end(), inputsig.begin(), inputsig.end());
++
++- //now run the test
+++ // now run the test
++ vlen = vlen - vlen_twiddle;
++ std::chrono::time_point<std::chrono::system_clock> start, end;
++ std::vector<double> profile_times;
++- for(size_t i = 0; i < arch_list.size(); i++) {
+++ for (size_t i = 0; i < arch_list.size(); i++) {
++ start = std::chrono::system_clock::now();
++
++- switch(both_sigs.size()) {
++- case 1:
++- if(inputsc.size() == 0) {
++- run_cast_test1((volk_fn_1arg)(manual_func), test_data[i], vlen, iter, arch_list[i]);
++- } else if(inputsc.size() == 1 && inputsc[0].is_float) {
++- if(inputsc[0].is_complex) {
++- run_cast_test1_s32fc((volk_fn_1arg_s32fc)(manual_func), test_data[i], scalar, vlen, iter, arch_list[i]);
++- } else {
++- run_cast_test1_s32f((volk_fn_1arg_s32f)(manual_func), test_data[i], scalar.real(), vlen, iter, arch_list[i]);
++- }
++- } else throw "unsupported 1 arg function >1 scalars";
++- break;
++- case 2:
++- if(inputsc.size() == 0) {
++- run_cast_test2((volk_fn_2arg)(manual_func), test_data[i], vlen, iter, arch_list[i]);
++- } else if(inputsc.size() == 1 && inputsc[0].is_float) {
++- if(inputsc[0].is_complex) {
++- run_cast_test2_s32fc((volk_fn_2arg_s32fc)(manual_func), test_data[i], scalar, vlen, iter, arch_list[i]);
++- } else {
++- run_cast_test2_s32f((volk_fn_2arg_s32f)(manual_func), test_data[i], scalar.real(), vlen, iter, arch_list[i]);
++- }
++- } else throw "unsupported 2 arg function >1 scalars";
++- break;
++- case 3:
++- if(inputsc.size() == 0) {
++- run_cast_test3((volk_fn_3arg)(manual_func), test_data[i], vlen, iter, arch_list[i]);
++- } else if(inputsc.size() == 1 && inputsc[0].is_float) {
++- if(inputsc[0].is_complex) {
++- run_cast_test3_s32fc((volk_fn_3arg_s32fc)(manual_func), test_data[i], scalar, vlen, iter, arch_list[i]);
++- } else {
++- run_cast_test3_s32f((volk_fn_3arg_s32f)(manual_func), test_data[i], scalar.real(), vlen, iter, arch_list[i]);
++- }
++- } else throw "unsupported 3 arg function >1 scalars";
++- break;
++- case 4:
++- run_cast_test4((volk_fn_4arg)(manual_func), test_data[i], vlen, iter, arch_list[i]);
++- break;
++- default:
++- throw "no function handler for this signature";
++- break;
+++ switch (both_sigs.size()) {
+++ case 1:
+++ if (inputsc.size() == 0) {
+++ run_cast_test1(
+++ (volk_fn_1arg)(manual_func), test_data[i], vlen, iter, arch_list[i]);
+++ } else if (inputsc.size() == 1 && inputsc[0].is_float) {
+++ if (inputsc[0].is_complex) {
+++ run_cast_test1_s32fc((volk_fn_1arg_s32fc)(manual_func),
+++ test_data[i],
+++ scalar,
+++ vlen,
+++ iter,
+++ arch_list[i]);
+++ } else {
+++ run_cast_test1_s32f((volk_fn_1arg_s32f)(manual_func),
+++ test_data[i],
+++ scalar.real(),
+++ vlen,
+++ iter,
+++ arch_list[i]);
+++ }
+++ } else
+++ throw "unsupported 1 arg function >1 scalars";
+++ break;
+++ case 2:
+++ if (inputsc.size() == 0) {
+++ run_cast_test2(
+++ (volk_fn_2arg)(manual_func), test_data[i], vlen, iter, arch_list[i]);
+++ } else if (inputsc.size() == 1 && inputsc[0].is_float) {
+++ if (inputsc[0].is_complex) {
+++ run_cast_test2_s32fc((volk_fn_2arg_s32fc)(manual_func),
+++ test_data[i],
+++ scalar,
+++ vlen,
+++ iter,
+++ arch_list[i]);
+++ } else {
+++ run_cast_test2_s32f((volk_fn_2arg_s32f)(manual_func),
+++ test_data[i],
+++ scalar.real(),
+++ vlen,
+++ iter,
+++ arch_list[i]);
+++ }
+++ } else
+++ throw "unsupported 2 arg function >1 scalars";
+++ break;
+++ case 3:
+++ if (inputsc.size() == 0) {
+++ run_cast_test3(
+++ (volk_fn_3arg)(manual_func), test_data[i], vlen, iter, arch_list[i]);
+++ } else if (inputsc.size() == 1 && inputsc[0].is_float) {
+++ if (inputsc[0].is_complex) {
+++ run_cast_test3_s32fc((volk_fn_3arg_s32fc)(manual_func),
+++ test_data[i],
+++ scalar,
+++ vlen,
+++ iter,
+++ arch_list[i]);
+++ } else {
+++ run_cast_test3_s32f((volk_fn_3arg_s32f)(manual_func),
+++ test_data[i],
+++ scalar.real(),
+++ vlen,
+++ iter,
+++ arch_list[i]);
+++ }
+++ } else
+++ throw "unsupported 3 arg function >1 scalars";
+++ break;
+++ case 4:
+++ run_cast_test4(
+++ (volk_fn_4arg)(manual_func), test_data[i], vlen, iter, arch_list[i]);
+++ break;
+++ default:
+++ throw "no function handler for this signature";
+++ break;
++ }
++
++ end = std::chrono::system_clock::now();
++@@ -541,10 +704,10 @@ bool run_volk_tests(volk_func_desc_t desc,
++ profile_times.push_back(arch_time);
++ }
++
++- //and now compare each output to the generic output
++- //first we have to know which output is the generic one, they aren't in order...
++- size_t generic_offset=0;
++- for(size_t i=0; i<arch_list.size(); i++) {
+++ // and now compare each output to the generic output
+++ // first we have to know which output is the generic one, they aren't in order...
+++ size_t generic_offset = 0;
+++ for (size_t i = 0; i < arch_list.size(); i++) {
++ if (arch_list[i] == "generic") {
++ generic_offset = i;
++ }
++@@ -555,72 +718,126 @@ bool run_volk_tests(volk_func_desc_t desc,
++ bool fail;
++ bool fail_global = false;
++ std::vector<bool> arch_results;
++- for(size_t i=0; i<arch_list.size(); i++) {
+++ for (size_t i = 0; i < arch_list.size(); i++) {
++ fail = false;
++- if(i != generic_offset) {
++- for(size_t j=0; j<both_sigs.size(); j++) {
++- if(both_sigs[j].is_float) {
++- if(both_sigs[j].size == 8) {
+++ if (i != generic_offset) {
+++ for (size_t j = 0; j < both_sigs.size(); j++) {
+++ if (both_sigs[j].is_float) {
+++ if (both_sigs[j].size == 8) {
++ if (both_sigs[j].is_complex) {
++- fail = ccompare((double *) test_data[generic_offset][j], (double *) test_data[i][j], vlen, tol_f, absolute_mode);
+++ fail = ccompare((double*)test_data[generic_offset][j],
+++ (double*)test_data[i][j],
+++ vlen,
+++ tol_f,
+++ absolute_mode);
++ } else {
++- fail = fcompare((double *) test_data[generic_offset][j], (double *) test_data[i][j], vlen, tol_f, absolute_mode);
+++ fail = fcompare((double*)test_data[generic_offset][j],
+++ (double*)test_data[i][j],
+++ vlen,
+++ tol_f,
+++ absolute_mode);
++ }
++ } else {
++ if (both_sigs[j].is_complex) {
++- fail = ccompare((float *) test_data[generic_offset][j], (float *) test_data[i][j], vlen, tol_f, absolute_mode);
+++ fail = ccompare((float*)test_data[generic_offset][j],
+++ (float*)test_data[i][j],
+++ vlen,
+++ tol_f,
+++ absolute_mode);
++ } else {
++- fail = fcompare((float *) test_data[generic_offset][j], (float *) test_data[i][j], vlen, tol_f, absolute_mode);
+++ fail = fcompare((float*)test_data[generic_offset][j],
+++ (float*)test_data[i][j],
+++ vlen,
+++ tol_f,
+++ absolute_mode);
++ }
++ }
++ } else {
++- //i could replace this whole switch statement with a memcmp if i wasn't interested in printing the outputs where they differ
++- switch(both_sigs[j].size) {
+++ // i could replace this whole switch statement with a memcmp if i
+++ // wasn't interested in printing the outputs where they differ
+++ switch (both_sigs[j].size) {
++ case 8:
++- if(both_sigs[j].is_signed) {
++- fail = icompare((int64_t *) test_data[generic_offset][j], (int64_t *) test_data[i][j], vlen*(both_sigs[j].is_complex ? 2 : 1), tol_i, absolute_mode);
+++ if (both_sigs[j].is_signed) {
+++ fail = icompare((int64_t*)test_data[generic_offset][j],
+++ (int64_t*)test_data[i][j],
+++ vlen * (both_sigs[j].is_complex ? 2 : 1),
+++ tol_i,
+++ absolute_mode);
++ } else {
++- fail = icompare((uint64_t *) test_data[generic_offset][j], (uint64_t *) test_data[i][j], vlen*(both_sigs[j].is_complex ? 2 : 1), tol_i, absolute_mode);
+++ fail = icompare((uint64_t*)test_data[generic_offset][j],
+++ (uint64_t*)test_data[i][j],
+++ vlen * (both_sigs[j].is_complex ? 2 : 1),
+++ tol_i,
+++ absolute_mode);
++ }
++ break;
++ case 4:
++- if(both_sigs[j].is_complex) {
++- if(both_sigs[j].is_signed) {
++- fail = icompare((int16_t *) test_data[generic_offset][j], (int16_t *) test_data[i][j], vlen*(both_sigs[j].is_complex ? 2 : 1), tol_i, absolute_mode);
+++ if (both_sigs[j].is_complex) {
+++ if (both_sigs[j].is_signed) {
+++ fail = icompare((int16_t*)test_data[generic_offset][j],
+++ (int16_t*)test_data[i][j],
+++ vlen * (both_sigs[j].is_complex ? 2 : 1),
+++ tol_i,
+++ absolute_mode);
++ } else {
++- fail = icompare((uint16_t *) test_data[generic_offset][j], (uint16_t *) test_data[i][j], vlen*(both_sigs[j].is_complex ? 2 : 1), tol_i, absolute_mode);
+++ fail = icompare((uint16_t*)test_data[generic_offset][j],
+++ (uint16_t*)test_data[i][j],
+++ vlen * (both_sigs[j].is_complex ? 2 : 1),
+++ tol_i,
+++ absolute_mode);
++ }
++- }
++- else {
+++ } else {
++ if (both_sigs[j].is_signed) {
++- fail = icompare((int32_t *) test_data[generic_offset][j], (int32_t *) test_data[i][j],
++- vlen * (both_sigs[j].is_complex ? 2 : 1), tol_i, absolute_mode);
+++ fail = icompare((int32_t*)test_data[generic_offset][j],
+++ (int32_t*)test_data[i][j],
+++ vlen * (both_sigs[j].is_complex ? 2 : 1),
+++ tol_i,
+++ absolute_mode);
++ } else {
++- fail = icompare((uint32_t *) test_data[generic_offset][j], (uint32_t *) test_data[i][j],
++- vlen * (both_sigs[j].is_complex ? 2 : 1), tol_i, absolute_mode);
+++ fail = icompare((uint32_t*)test_data[generic_offset][j],
+++ (uint32_t*)test_data[i][j],
+++ vlen * (both_sigs[j].is_complex ? 2 : 1),
+++ tol_i,
+++ absolute_mode);
++ }
++ }
++ break;
++ case 2:
++- if(both_sigs[j].is_signed) {
++- fail = icompare((int16_t *) test_data[generic_offset][j], (int16_t *) test_data[i][j], vlen*(both_sigs[j].is_complex ? 2 : 1), tol_i, absolute_mode);
+++ if (both_sigs[j].is_signed) {
+++ fail = icompare((int16_t*)test_data[generic_offset][j],
+++ (int16_t*)test_data[i][j],
+++ vlen * (both_sigs[j].is_complex ? 2 : 1),
+++ tol_i,
+++ absolute_mode);
++ } else {
++- fail = icompare((uint16_t *) test_data[generic_offset][j], (uint16_t *) test_data[i][j], vlen*(both_sigs[j].is_complex ? 2 : 1), tol_i, absolute_mode);
+++ fail = icompare((uint16_t*)test_data[generic_offset][j],
+++ (uint16_t*)test_data[i][j],
+++ vlen * (both_sigs[j].is_complex ? 2 : 1),
+++ tol_i,
+++ absolute_mode);
++ }
++ break;
++ case 1:
++- if(both_sigs[j].is_signed) {
++- fail = icompare((int8_t *) test_data[generic_offset][j], (int8_t *) test_data[i][j], vlen*(both_sigs[j].is_complex ? 2 : 1), tol_i, absolute_mode);
+++ if (both_sigs[j].is_signed) {
+++ fail = icompare((int8_t*)test_data[generic_offset][j],
+++ (int8_t*)test_data[i][j],
+++ vlen * (both_sigs[j].is_complex ? 2 : 1),
+++ tol_i,
+++ absolute_mode);
++ } else {
++- fail = icompare((uint8_t *) test_data[generic_offset][j], (uint8_t *) test_data[i][j], vlen*(both_sigs[j].is_complex ? 2 : 1), tol_i, absolute_mode);
+++ fail = icompare((uint8_t*)test_data[generic_offset][j],
+++ (uint8_t*)test_data[i][j],
+++ vlen * (both_sigs[j].is_complex ? 2 : 1),
+++ tol_i,
+++ absolute_mode);
++ }
++ break;
++ default:
++- fail=1;
+++ fail = 1;
++ }
++ }
++- if(fail) {
++- volk_test_time_t *result = &results->back().results[arch_list[i]];
+++ if (fail) {
+++ volk_test_time_t* result = &results->back().results[arch_list[i]];
++ result->pass = false;
++ fail_global = true;
++ std::cout << name << ": fail on arch " << arch_list[i] << std::endl;
++@@ -634,15 +851,13 @@ bool run_volk_tests(volk_func_desc_t desc,
++ double best_time_u = std::numeric_limits<double>::max();
++ std::string best_arch_a = "generic";
++ std::string best_arch_u = "generic";
++- for(size_t i=0; i < arch_list.size(); i++)
++- {
++- if((profile_times[i] < best_time_u) && arch_results[i] && desc.impl_alignment[i] == 0)
++- {
+++ for (size_t i = 0; i < arch_list.size(); i++) {
+++ if ((profile_times[i] < best_time_u) && arch_results[i] &&
+++ desc.impl_alignment[i] == 0) {
++ best_time_u = profile_times[i];
++ best_arch_u = arch_list[i];
++ }
++- if((profile_times[i] < best_time_a) && arch_results[i])
++- {
+++ if ((profile_times[i] < best_time_a) && arch_results[i]) {
++ best_time_a = profile_times[i];
++ best_arch_a = arch_list[i];
++ }
++@@ -651,7 +866,7 @@ bool run_volk_tests(volk_func_desc_t desc,
++ std::cout << "Best aligned arch: " << best_arch_a << std::endl;
++ std::cout << "Best unaligned arch: " << best_arch_u << std::endl;
++
++- if(puppet_master_name == "NULL") {
+++ if (puppet_master_name == "NULL") {
++ results->back().config_name = name;
++ } else {
++ results->back().config_name = puppet_master_name;
++diff --git a/lib/qa_utils.h b/lib/qa_utils.h
++index 2d8458b..74c3db4 100644
++--- a/lib/qa_utils.h
+++++ b/lib/qa_utils.h
++@@ -1,14 +1,14 @@
++ #ifndef VOLK_QA_UTILS_H
++ #define VOLK_QA_UTILS_H
++
++-#include <stdbool.h> // for bool, false
++-#include <volk/volk.h> // for volk_func_desc_t
++-#include <cstdlib> // for NULL
++-#include <map> // for map
++-#include <string> // for string, basic_string
++-#include <vector> // for vector
+++#include <stdbool.h> // for bool, false
+++#include <volk/volk.h> // for volk_func_desc_t
+++#include <cstdlib> // for NULL
+++#include <map> // for map
+++#include <string> // for string, basic_string
+++#include <vector> // for vector
++
++-#include "volk/volk_complex.h" // for lv_32fc_t
+++#include "volk/volk_complex.h" // for lv_32fc_t
++
++ /************************************************
++ * VOLK QA type definitions *
++@@ -22,93 +22,119 @@ struct volk_type_t {
++ std::string str;
++ };
++
++-class volk_test_time_t {
++- public:
++- std::string name;
++- double time;
++- std::string units;
++- bool pass;
+++class volk_test_time_t
+++{
+++public:
+++ std::string name;
+++ double time;
+++ std::string units;
+++ bool pass;
++ };
++
++-class volk_test_results_t {
++- public:
++- std::string name;
++- std::string config_name;
++- unsigned int vlen;
++- unsigned int iter;
++- std::map<std::string, volk_test_time_t> results;
++- std::string best_arch_a;
++- std::string best_arch_u;
+++class volk_test_results_t
+++{
+++public:
+++ std::string name;
+++ std::string config_name;
+++ unsigned int vlen;
+++ unsigned int iter;
+++ std::map<std::string, volk_test_time_t> results;
+++ std::string best_arch_a;
+++ std::string best_arch_u;
++ };
++
++-class volk_test_params_t {
++- private:
++- float _tol;
++- lv_32fc_t _scalar;
++- unsigned int _vlen;
++- unsigned int _iter;
++- bool _benchmark_mode;
++- bool _absolute_mode;
++- std::string _kernel_regex;
++- public:
++- // ctor
++- volk_test_params_t(float tol, lv_32fc_t scalar, unsigned int vlen, unsigned int iter,
++- bool benchmark_mode, std::string kernel_regex) :
++- _tol(tol), _scalar(scalar), _vlen(vlen), _iter(iter),
++- _benchmark_mode(benchmark_mode), _absolute_mode(false), _kernel_regex(kernel_regex) {};
++- // setters
++- void set_tol(float tol) {_tol=tol;};
++- void set_scalar(lv_32fc_t scalar) {_scalar=scalar;};
++- void set_vlen(unsigned int vlen) {_vlen=vlen;};
++- void set_iter(unsigned int iter) {_iter=iter;};
++- void set_benchmark(bool benchmark) {_benchmark_mode=benchmark;};
++- void set_regex(std::string regex) {_kernel_regex=regex;};
++- // getters
++- float tol() {return _tol;};
++- lv_32fc_t scalar() {return _scalar;};
++- unsigned int vlen() {return _vlen;};
++- unsigned int iter() {return _iter;};
++- bool benchmark_mode() {return _benchmark_mode;};
++- bool absolute_mode() {return _absolute_mode;};
++- std::string kernel_regex() {return _kernel_regex;};
++- volk_test_params_t make_absolute(float tol) {
++- volk_test_params_t t(*this);
++- t._tol = tol;
++- t._absolute_mode = true;
++- return t;
++- }
++- volk_test_params_t make_tol(float tol) {
++- volk_test_params_t t(*this);
++- t._tol = tol;
++- return t;
++- }
+++class volk_test_params_t
+++{
+++private:
+++ float _tol;
+++ lv_32fc_t _scalar;
+++ unsigned int _vlen;
+++ unsigned int _iter;
+++ bool _benchmark_mode;
+++ bool _absolute_mode;
+++ std::string _kernel_regex;
+++
+++public:
+++ // ctor
+++ volk_test_params_t(float tol,
+++ lv_32fc_t scalar,
+++ unsigned int vlen,
+++ unsigned int iter,
+++ bool benchmark_mode,
+++ std::string kernel_regex)
+++ : _tol(tol),
+++ _scalar(scalar),
+++ _vlen(vlen),
+++ _iter(iter),
+++ _benchmark_mode(benchmark_mode),
+++ _absolute_mode(false),
+++ _kernel_regex(kernel_regex){};
+++ // setters
+++ void set_tol(float tol) { _tol = tol; };
+++ void set_scalar(lv_32fc_t scalar) { _scalar = scalar; };
+++ void set_vlen(unsigned int vlen) { _vlen = vlen; };
+++ void set_iter(unsigned int iter) { _iter = iter; };
+++ void set_benchmark(bool benchmark) { _benchmark_mode = benchmark; };
+++ void set_regex(std::string regex) { _kernel_regex = regex; };
+++ // getters
+++ float tol() { return _tol; };
+++ lv_32fc_t scalar() { return _scalar; };
+++ unsigned int vlen() { return _vlen; };
+++ unsigned int iter() { return _iter; };
+++ bool benchmark_mode() { return _benchmark_mode; };
+++ bool absolute_mode() { return _absolute_mode; };
+++ std::string kernel_regex() { return _kernel_regex; };
+++ volk_test_params_t make_absolute(float tol)
+++ {
+++ volk_test_params_t t(*this);
+++ t._tol = tol;
+++ t._absolute_mode = true;
+++ return t;
+++ }
+++ volk_test_params_t make_tol(float tol)
+++ {
+++ volk_test_params_t t(*this);
+++ t._tol = tol;
+++ return t;
+++ }
++ };
++
++-class volk_test_case_t {
++- private:
++- volk_func_desc_t _desc;
++- void(*_kernel_ptr)();
++- std::string _name;
++- volk_test_params_t _test_parameters;
++- std::string _puppet_master_name;
++- public:
++- volk_func_desc_t desc() {return _desc;};
++- void (*kernel_ptr()) () {return _kernel_ptr;};
++- std::string name() {return _name;};
++- std::string puppet_master_name() {return _puppet_master_name;};
++- volk_test_params_t test_parameters() {return _test_parameters;};
++- // normal ctor
++- volk_test_case_t(volk_func_desc_t desc, void(*kernel_ptr)(), std::string name,
++- volk_test_params_t test_parameters) :
++- _desc(desc), _kernel_ptr(kernel_ptr), _name(name), _test_parameters(test_parameters),
++- _puppet_master_name("NULL")
++- {};
++- // ctor for puppets
++- volk_test_case_t(volk_func_desc_t desc, void(*kernel_ptr)(), std::string name,
++- std::string puppet_master_name, volk_test_params_t test_parameters) :
++- _desc(desc), _kernel_ptr(kernel_ptr), _name(name), _test_parameters(test_parameters),
++- _puppet_master_name(puppet_master_name)
++- {};
+++class volk_test_case_t
+++{
+++private:
+++ volk_func_desc_t _desc;
+++ void (*_kernel_ptr)();
+++ std::string _name;
+++ volk_test_params_t _test_parameters;
+++ std::string _puppet_master_name;
+++
+++public:
+++ volk_func_desc_t desc() { return _desc; };
+++ void (*kernel_ptr())() { return _kernel_ptr; };
+++ std::string name() { return _name; };
+++ std::string puppet_master_name() { return _puppet_master_name; };
+++ volk_test_params_t test_parameters() { return _test_parameters; };
+++ // normal ctor
+++ volk_test_case_t(volk_func_desc_t desc,
+++ void (*kernel_ptr)(),
+++ std::string name,
+++ volk_test_params_t test_parameters)
+++ : _desc(desc),
+++ _kernel_ptr(kernel_ptr),
+++ _name(name),
+++ _test_parameters(test_parameters),
+++ _puppet_master_name("NULL"){};
+++ // ctor for puppets
+++ volk_test_case_t(volk_func_desc_t desc,
+++ void (*kernel_ptr)(),
+++ std::string name,
+++ std::string puppet_master_name,
+++ volk_test_params_t test_parameters)
+++ : _desc(desc),
+++ _kernel_ptr(kernel_ptr),
+++ _name(name),
+++ _test_parameters(test_parameters),
+++ _puppet_master_name(puppet_master_name){};
++ };
++
++ /************************************************
++@@ -117,42 +143,58 @@ class volk_test_case_t {
++ volk_type_t volk_type_from_string(std::string);
++
++ float uniform(void);
++-void random_floats(float *buf, unsigned n);
+++void random_floats(float* buf, unsigned n);
++
++-bool run_volk_tests(
++- volk_func_desc_t,
++- void(*)(),
++- std::string,
++- volk_test_params_t,
++- std::vector<volk_test_results_t> *results = NULL,
++- std::string puppet_master_name = "NULL"
++- );
+++bool run_volk_tests(volk_func_desc_t,
+++ void (*)(),
+++ std::string,
+++ volk_test_params_t,
+++ std::vector<volk_test_results_t>* results = NULL,
+++ std::string puppet_master_name = "NULL");
++
++-bool run_volk_tests(
++- volk_func_desc_t,
++- void(*)(),
++- std::string,
++- float,
++- lv_32fc_t,
++- unsigned int,
++- unsigned int,
++- std::vector<volk_test_results_t> *results = NULL,
++- std::string puppet_master_name = "NULL",
++- bool absolute_mode = false,
++- bool benchmark_mode = false
++-);
+++bool run_volk_tests(volk_func_desc_t,
+++ void (*)(),
+++ std::string,
+++ float,
+++ lv_32fc_t,
+++ unsigned int,
+++ unsigned int,
+++ std::vector<volk_test_results_t>* results = NULL,
+++ std::string puppet_master_name = "NULL",
+++ bool absolute_mode = false,
+++ bool benchmark_mode = false);
++
++-#define VOLK_PROFILE(func, test_params, results) run_volk_tests(func##_get_func_desc(), (void (*)())func##_manual, std::string(#func), test_params, results, "NULL")
++-#define VOLK_PUPPET_PROFILE(func, puppet_master_func, test_params, results) run_volk_tests(func##_get_func_desc(), (void (*)())func##_manual, std::string(#func), test_params, results, std::string(#puppet_master_func))
++-typedef void (*volk_fn_1arg)(void *, unsigned int, const char*); //one input, operate in place
++-typedef void (*volk_fn_2arg)(void *, void *, unsigned int, const char*);
++-typedef void (*volk_fn_3arg)(void *, void *, void *, unsigned int, const char*);
++-typedef void (*volk_fn_4arg)(void *, void *, void *, void *, unsigned int, const char*);
++-typedef void (*volk_fn_1arg_s32f)(void *, float, unsigned int, const char*); //one input vector, one scalar float input
++-typedef void (*volk_fn_2arg_s32f)(void *, void *, float, unsigned int, const char*);
++-typedef void (*volk_fn_3arg_s32f)(void *, void *, void *, float, unsigned int, const char*);
++-typedef void (*volk_fn_1arg_s32fc)(void *, lv_32fc_t, unsigned int, const char*); //one input vector, one scalar float input
++-typedef void (*volk_fn_2arg_s32fc)(void *, void *, lv_32fc_t, unsigned int, const char*);
++-typedef void (*volk_fn_3arg_s32fc)(void *, void *, void *, lv_32fc_t, unsigned int, const char*);
+++#define VOLK_PROFILE(func, test_params, results) \
+++ run_volk_tests(func##_get_func_desc(), \
+++ (void (*)())func##_manual, \
+++ std::string(#func), \
+++ test_params, \
+++ results, \
+++ "NULL")
+++#define VOLK_PUPPET_PROFILE(func, puppet_master_func, test_params, results) \
+++ run_volk_tests(func##_get_func_desc(), \
+++ (void (*)())func##_manual, \
+++ std::string(#func), \
+++ test_params, \
+++ results, \
+++ std::string(#puppet_master_func))
+++typedef void (*volk_fn_1arg)(void*,
+++ unsigned int,
+++ const char*); // one input, operate in place
+++typedef void (*volk_fn_2arg)(void*, void*, unsigned int, const char*);
+++typedef void (*volk_fn_3arg)(void*, void*, void*, unsigned int, const char*);
+++typedef void (*volk_fn_4arg)(void*, void*, void*, void*, unsigned int, const char*);
+++typedef void (*volk_fn_1arg_s32f)(
+++ void*, float, unsigned int, const char*); // one input vector, one scalar float input
+++typedef void (*volk_fn_2arg_s32f)(void*, void*, float, unsigned int, const char*);
+++typedef void (*volk_fn_3arg_s32f)(void*, void*, void*, float, unsigned int, const char*);
+++typedef void (*volk_fn_1arg_s32fc)(
+++ void*,
+++ lv_32fc_t,
+++ unsigned int,
+++ const char*); // one input vector, one scalar float input
+++typedef void (*volk_fn_2arg_s32fc)(void*, void*, lv_32fc_t, unsigned int, const char*);
+++typedef void (*volk_fn_3arg_s32fc)(
+++ void*, void*, void*, lv_32fc_t, unsigned int, const char*);
++
++-#endif //VOLK_QA_UTILS_H
+++#endif // VOLK_QA_UTILS_H
++diff --git a/lib/testqa.cc b/lib/testqa.cc
++index 8b0f4d6..c885383 100644
++--- a/lib/testqa.cc
+++++ b/lib/testqa.cc
++@@ -20,18 +20,18 @@
++ * Boston, MA 02110-1301, USA.
++ */
++
++-#include <stdbool.h> // for bool, false, true
++-#include <iostream> // for operator<<, basic_ostream, endl, char...
++-#include <fstream> // IWYU pragma: keep
++-#include <map> // for map, map<>::iterator, _Rb_tree_iterator
++-#include <string> // for string, operator<<
++-#include <utility> // for pair
++-#include <vector> // for vector
++-
+++#include <stdbool.h> // for bool, false, true
+++#include <fstream> // IWYU pragma: keep
+++#include <iostream> // for operator<<, basic_ostream, endl, char...
+++#include <map> // for map, map<>::iterator, _Rb_tree_iterator
+++#include <string> // for string, operator<<
+++#include <utility> // for pair
+++#include <vector> // for vector
+++
+++#include "kernel_tests.h" // for init_test_list
+++#include "qa_utils.h" // for volk_test_case_t, volk_test_results_t
+++#include "volk/volk_complex.h" // for lv_32fc_t
++ #include <volk/volk.h>
++-#include "kernel_tests.h" // for init_test_list
++-#include "qa_utils.h" // for volk_test_case_t, volk_test_results_t
++-#include "volk/volk_complex.h" // for lv_32fc_t
++
++ void print_qa_xml(std::vector<volk_test_results_t> results, unsigned int nfails);
++
++@@ -46,45 +46,52 @@ int main(int argc, char* argv[])
++ bool def_benchmark_mode = true;
++ std::string def_kernel_regex = "";
++
++- volk_test_params_t test_params(def_tol, def_scalar, def_vlen, def_iter,
++- def_benchmark_mode, def_kernel_regex);
+++ volk_test_params_t test_params(
+++ def_tol, def_scalar, def_vlen, def_iter, def_benchmark_mode, def_kernel_regex);
++ std::vector<volk_test_case_t> test_cases = init_test_list(test_params);
++ std::vector<volk_test_results_t> results;
++
++- if (argc > 1){
++- for(unsigned int ii = 0; ii < test_cases.size(); ++ii){
++- if (std::string(argv[1]) == test_cases[ii].name()){
+++ if (argc > 1) {
+++ for (unsigned int ii = 0; ii < test_cases.size(); ++ii) {
+++ if (std::string(argv[1]) == test_cases[ii].name()) {
++ volk_test_case_t test_case = test_cases[ii];
++- if (run_volk_tests(test_case.desc(), test_case.kernel_ptr(),
+++ if (run_volk_tests(test_case.desc(),
+++ test_case.kernel_ptr(),
++ test_case.name(),
++- test_case.test_parameters(), &results,
+++ test_case.test_parameters(),
+++ &results,
++ test_case.puppet_master_name())) {
++- return 1;
+++ return 1;
++ } else {
++- return 0;
+++ return 0;
++ }
++ }
++ }
++- std::cerr << "Did not run a test for kernel: " << std::string(argv[1]) << " !" << std::endl;
+++ std::cerr << "Did not run a test for kernel: " << std::string(argv[1]) << " !"
+++ << std::endl;
++ return 0;
++
++- }else{
+++ } else {
++ std::vector<std::string> qa_failures;
++ // Test every kernel reporting failures when they occur
++- for(unsigned int ii = 0; ii < test_cases.size(); ++ii) {
+++ for (unsigned int ii = 0; ii < test_cases.size(); ++ii) {
++ bool qa_result = false;
++ volk_test_case_t test_case = test_cases[ii];
++ try {
++- qa_result = run_volk_tests(test_case.desc(), test_case.kernel_ptr(), test_case.name(),
++- test_case.test_parameters(), &results, test_case.puppet_master_name());
++- }
++- catch(...) {
+++ qa_result = run_volk_tests(test_case.desc(),
+++ test_case.kernel_ptr(),
+++ test_case.name(),
+++ test_case.test_parameters(),
+++ &results,
+++ test_case.puppet_master_name());
+++ } catch (...) {
++ // TODO: what exceptions might we need to catch and how do we handle them?
++- std::cerr << "Exception found on kernel: " << test_case.name() << std::endl;
+++ std::cerr << "Exception found on kernel: " << test_case.name()
+++ << std::endl;
++ qa_result = false;
++ }
++
++- if(qa_result) {
+++ if (qa_result) {
++ std::cerr << "Failure on " << test_case.name() << std::endl;
++ qa_failures.push_back(test_case.name());
++ }
++@@ -96,9 +103,9 @@ int main(int argc, char* argv[])
++ // Summarize QA results
++ std::cerr << "Kernel QA finished: " << qa_failures.size() << " failures out of "
++ << test_cases.size() << " tests." << std::endl;
++- if(qa_failures.size() > 0) {
+++ if (qa_failures.size() > 0) {
++ std::cerr << "The following kernels failed QA:" << std::endl;
++- for(unsigned int ii = 0; ii < qa_failures.size(); ++ii) {
+++ for (unsigned int ii = 0; ii < qa_failures.size(); ++ii) {
++ std::cerr << " " << qa_failures[ii] << std::endl;
++ }
++ qa_ret_val = 1;
++@@ -118,26 +125,28 @@ void print_qa_xml(std::vector<volk_test_results_t> results, unsigned int nfails)
++ qa_file.open(".unittest/kernels.xml");
++
++ qa_file << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
++- qa_file << "<testsuites name=\"kernels\" " <<
++- "tests=\"" << results.size() << "\" " <<
++- "failures=\"" << nfails << "\" id=\"1\">" << std::endl;
+++ qa_file << "<testsuites name=\"kernels\" "
+++ << "tests=\"" << results.size() << "\" "
+++ << "failures=\"" << nfails << "\" id=\"1\">" << std::endl;
++
++ // Results are in a vector by kernel. Each element has a result
++ // map containing time and arch name with test result
++- for(unsigned int ii=0; ii < results.size(); ++ii) {
+++ for (unsigned int ii = 0; ii < results.size(); ++ii) {
++ volk_test_results_t result = results[ii];
++ qa_file << " <testsuite name=\"" << result.name << "\">" << std::endl;
++
++ std::map<std::string, volk_test_time_t>::iterator kernel_time_pair;
++- for(kernel_time_pair = result.results.begin(); kernel_time_pair != result.results.end(); ++kernel_time_pair) {
+++ for (kernel_time_pair = result.results.begin();
+++ kernel_time_pair != result.results.end();
+++ ++kernel_time_pair) {
++ volk_test_time_t test_time = kernel_time_pair->second;
++- qa_file << " <testcase name=\"" << test_time.name << "\" " <<
++- "classname=\"" << result.name << "\" " <<
++- "time=\"" << test_time.time << "\">" << std::endl;
++- if(!test_time.pass)
++- qa_file << " <failure " <<
++- "message=\"fail on arch " << test_time.name << "\">" <<
++- "</failure>" << std::endl;
+++ qa_file << " <testcase name=\"" << test_time.name << "\" "
+++ << "classname=\"" << result.name << "\" "
+++ << "time=\"" << test_time.time << "\">" << std::endl;
+++ if (!test_time.pass)
+++ qa_file << " <failure "
+++ << "message=\"fail on arch " << test_time.name << "\">"
+++ << "</failure>" << std::endl;
++ qa_file << " </testcase>" << std::endl;
++ }
++ qa_file << " </testsuite>" << std::endl;
++@@ -146,5 +155,4 @@ void print_qa_xml(std::vector<volk_test_results_t> results, unsigned int nfails)
++
++ qa_file << "</testsuites>" << std::endl;
++ qa_file.close();
++-
++ }
++diff --git a/lib/volk_malloc.c b/lib/volk_malloc.c
++index df36240..b3779e1 100644
++--- a/lib/volk_malloc.c
+++++ b/lib/volk_malloc.c
++@@ -31,7 +31,8 @@
++ * see: https://en.cppreference.com/w/c/memory/aligned_alloc
++ *
++ * MSVC is broken
++- * see: https://docs.microsoft.com/en-us/cpp/overview/visual-cpp-language-conformance?view=vs-2019
+++ * see:
+++ * https://docs.microsoft.com/en-us/cpp/overview/visual-cpp-language-conformance?view=vs-2019
++ * This section:
++ * C11 The Universal CRT implemented the parts of the
++ * C11 Standard Library that are required by C++17,
++@@ -46,39 +47,43 @@
++ * We must work around this problem because MSVC is non-compliant!
++ */
++
++-void *volk_malloc(size_t size, size_t alignment)
+++
+++void* volk_malloc(size_t size, size_t alignment)
++ {
++ #if HAVE_POSIX_MEMALIGN
++- // quoting posix_memalign() man page:
++- // "alignment must be a power of two and a multiple of sizeof(void *)"
++- // volk_get_alignment() could return 1 for some machines (e.g. generic_orc)
++- if (alignment == 1){
++- return malloc(size);
++- }
++- void *ptr;
++- int err = posix_memalign(&ptr, alignment, size);
++- if(err != 0) {
++- ptr = NULL;
++- fprintf(stderr,
++- "VOLK: Error allocating memory "
++- "(posix_memalign: error %d: %s)\n", err, strerror(err));
++- }
+++ // quoting posix_memalign() man page:
+++ // "alignment must be a power of two and a multiple of sizeof(void *)"
+++ // volk_get_alignment() could return 1 for some machines (e.g. generic_orc)
+++ if (alignment == 1) {
+++ return malloc(size);
+++ }
+++ void* ptr;
+++ int err = posix_memalign(&ptr, alignment, size);
+++ if (err != 0) {
+++ ptr = NULL;
+++ fprintf(stderr,
+++ "VOLK: Error allocating memory "
+++ "(posix_memalign: error %d: %s)\n",
+++ err,
+++ strerror(err));
+++ }
++ #elif defined(_MSC_VER)
++- void *ptr = _aligned_malloc(size, alignment);
+++ void* ptr = _aligned_malloc(size, alignment);
++ #else
++- void *ptr = aligned_alloc(alignment, size);
+++ void* ptr = aligned_alloc(alignment, size);
++ #endif
++- if(ptr == NULL) {
++- fprintf(stderr, "VOLK: Error allocating memory (aligned_alloc/_aligned_malloc)\n");
++- }
++- return ptr;
+++ if (ptr == NULL) {
+++ fprintf(stderr,
+++ "VOLK: Error allocating memory (aligned_alloc/_aligned_malloc)\n");
+++ }
+++ return ptr;
++ }
++
++-void volk_free(void *ptr)
+++void volk_free(void* ptr)
++ {
++ #if defined(_MSC_VER)
++- _aligned_free(ptr);
+++ _aligned_free(ptr);
++ #else
++- free(ptr);
+++ free(ptr);
++ #endif
++ }
++diff --git a/lib/volk_prefs.c b/lib/volk_prefs.c
++index 0b5fe8e..8934bf7 100644
++--- a/lib/volk_prefs.c
+++++ b/lib/volk_prefs.c
++@@ -1,6 +1,6 @@
+++#include <stdbool.h>
++ #include <stdio.h>
++ #include <stdlib.h>
++-#include <stdbool.h>
++ #include <string.h>
++ #if defined(_MSC_VER)
++ #include <io.h>
++@@ -11,82 +11,84 @@
++ #endif
++ #include <volk/volk_prefs.h>
++
++-void volk_get_config_path(char *path, bool read)
+++void volk_get_config_path(char* path, bool read)
++ {
++- if (!path) return;
++- const char *suffix = "/.volk/volk_config";
++- const char *suffix2 = "/volk/volk_config"; //non-hidden
++- char *home = NULL;
+++ if (!path)
+++ return;
+++ const char* suffix = "/.volk/volk_config";
+++ const char* suffix2 = "/volk/volk_config"; // non-hidden
+++ char* home = NULL;
++
++- //allows config redirection via env variable
+++ // allows config redirection via env variable
++ home = getenv("VOLK_CONFIGPATH");
++- if(home!=NULL){
++- strncpy(path,home,512);
++- strcat(path,suffix2);
++- if (!read || access(path, F_OK) != -1){
+++ if (home != NULL) {
+++ strncpy(path, home, 512);
+++ strcat(path, suffix2);
+++ if (!read || access(path, F_OK) != -1) {
++ return;
++ }
++ }
++
++- //check for user-local config file
+++ // check for user-local config file
++ home = getenv("HOME");
++- if (home != NULL){
+++ if (home != NULL) {
++ strncpy(path, home, 512);
++ strcat(path, suffix);
++- if (!read || (access(path, F_OK) != -1)){
+++ if (!read || (access(path, F_OK) != -1)) {
++ return;
++ }
++ }
++
++- //check for config file in APPDATA (Windows)
+++ // check for config file in APPDATA (Windows)
++ home = getenv("APPDATA");
++- if (home != NULL){
+++ if (home != NULL) {
++ strncpy(path, home, 512);
++ strcat(path, suffix);
++- if (!read || (access(path, F_OK) != -1)){
+++ if (!read || (access(path, F_OK) != -1)) {
++ return;
++ }
++ }
++
++- //check for system-wide config file
++- if (access("/etc/volk/volk_config", F_OK) != -1){
+++ // check for system-wide config file
+++ if (access("/etc/volk/volk_config", F_OK) != -1) {
++ strncpy(path, "/etc", 512);
++ strcat(path, suffix2);
++- if (!read || (access(path, F_OK) != -1)){
+++ if (!read || (access(path, F_OK) != -1)) {
++ return;
++ }
++ }
++
++- //If still no path was found set path[0] to '0' and fall through
+++ // If still no path was found set path[0] to '0' and fall through
++ path[0] = 0;
++ return;
++ }
++
++-size_t volk_load_preferences(volk_arch_pref_t **prefs_res)
+++size_t volk_load_preferences(volk_arch_pref_t** prefs_res)
++ {
++- FILE *config_file;
+++ FILE* config_file;
++ char path[512], line[512];
++ size_t n_arch_prefs = 0;
++- volk_arch_pref_t *prefs = NULL;
+++ volk_arch_pref_t* prefs = NULL;
++
++- //get the config path
+++ // get the config path
++ volk_get_config_path(path, true);
++- if (!path[0]) return n_arch_prefs; //no prefs found
+++ if (!path[0])
+++ return n_arch_prefs; // no prefs found
++ config_file = fopen(path, "r");
++- if(!config_file) return n_arch_prefs; //no prefs found
+++ if (!config_file)
+++ return n_arch_prefs; // no prefs found
++
++- //reset the file pointer and write the prefs into volk_arch_prefs
++- while(fgets(line, sizeof(line), config_file) != NULL)
++- {
++- void *new_prefs = realloc(prefs, (n_arch_prefs + 1) * sizeof(*prefs));
+++ // reset the file pointer and write the prefs into volk_arch_prefs
+++ while (fgets(line, sizeof(line), config_file) != NULL) {
+++ void* new_prefs = realloc(prefs, (n_arch_prefs + 1) * sizeof(*prefs));
++ if (!new_prefs) {
++- printf ("volk_load_preferences: bad malloc\n");
+++ printf("volk_load_preferences: bad malloc\n");
++ break;
++ }
++- prefs = (volk_arch_pref_t *) new_prefs;
++- volk_arch_pref_t *p = prefs + n_arch_prefs;
++- if(sscanf(line, "%s %s %s", p->name, p->impl_a, p->impl_u) == 3 && !strncmp(p->name, "volk_", 5))
++- {
+++ prefs = (volk_arch_pref_t*)new_prefs;
+++ volk_arch_pref_t* p = prefs + n_arch_prefs;
+++ if (sscanf(line, "%s %s %s", p->name, p->impl_a, p->impl_u) == 3 &&
+++ !strncmp(p->name, "volk_", 5)) {
++ n_arch_prefs++;
++ }
++ }
++diff --git a/lib/volk_rank_archs.c b/lib/volk_rank_archs.c
++index 346619e..7cf3fd7 100644
++--- a/lib/volk_rank_archs.c
+++++ b/lib/volk_rank_archs.c
++@@ -24,84 +24,83 @@
++ #include <stdlib.h>
++ #include <string.h>
++
++-#include <volk_rank_archs.h>
++ #include <volk/volk_prefs.h>
+++#include <volk_rank_archs.h>
++
++-int volk_get_index(
++- const char *impl_names[], //list of implementations by name
++- const size_t n_impls, //number of implementations available
++- const char *impl_name //the implementation name to find
++-){
+++int volk_get_index(const char* impl_names[], // list of implementations by name
+++ const size_t n_impls, // number of implementations available
+++ const char* impl_name // the implementation name to find
+++)
+++{
++ unsigned int i;
++ for (i = 0; i < n_impls; i++) {
++- if(!strncmp(impl_names[i], impl_name, 20)) {
+++ if (!strncmp(impl_names[i], impl_name, 20)) {
++ return i;
++ }
++ }
++- //TODO return -1;
++- //something terrible should happen here
+++ // TODO return -1;
+++ // something terrible should happen here
++ fprintf(stderr, "Volk warning: no arch found, returning generic impl\n");
++- return volk_get_index(impl_names, n_impls, "generic"); //but we'll fake it for now
+++ return volk_get_index(impl_names, n_impls, "generic"); // but we'll fake it for now
++ }
++
++-int volk_rank_archs(
++- const char *kern_name, //name of the kernel to rank
++- const char *impl_names[], //list of implementations by name
++- const int* impl_deps, //requirement mask per implementation
++- const bool* alignment, //alignment status of each implementation
++- size_t n_impls, //number of implementations available
++- const bool align //if false, filter aligned implementations
+++int volk_rank_archs(const char* kern_name, // name of the kernel to rank
+++ const char* impl_names[], // list of implementations by name
+++ const int* impl_deps, // requirement mask per implementation
+++ const bool* alignment, // alignment status of each implementation
+++ size_t n_impls, // number of implementations available
+++ const bool align // if false, filter aligned implementations
++ )
++ {
++ size_t i;
++- static volk_arch_pref_t *volk_arch_prefs;
+++ static volk_arch_pref_t* volk_arch_prefs;
++ static size_t n_arch_prefs = 0;
++ static int prefs_loaded = 0;
++- if(!prefs_loaded) {
+++ if (!prefs_loaded) {
++ n_arch_prefs = volk_load_preferences(&volk_arch_prefs);
++ prefs_loaded = 1;
++ }
++
++ // If we've defined VOLK_GENERIC to be anything, always return the
++ // 'generic' kernel. Used in GR's QA code.
++- char *gen_env = getenv("VOLK_GENERIC");
++- if(gen_env) {
++- return volk_get_index(impl_names, n_impls, "generic");
+++ char* gen_env = getenv("VOLK_GENERIC");
+++ if (gen_env) {
+++ return volk_get_index(impl_names, n_impls, "generic");
++ }
++
++- //now look for the function name in the prefs list
++- for(i = 0; i < n_arch_prefs; i++)
++- {
++- if(!strncmp(kern_name, volk_arch_prefs[i].name, sizeof(volk_arch_prefs[i].name))) //found it
+++ // now look for the function name in the prefs list
+++ for (i = 0; i < n_arch_prefs; i++) {
+++ if (!strncmp(kern_name,
+++ volk_arch_prefs[i].name,
+++ sizeof(volk_arch_prefs[i].name))) // found it
++ {
++- const char *impl_name = align? volk_arch_prefs[i].impl_a : volk_arch_prefs[i].impl_u;
+++ const char* impl_name =
+++ align ? volk_arch_prefs[i].impl_a : volk_arch_prefs[i].impl_u;
++ return volk_get_index(impl_names, n_impls, impl_name);
++ }
++ }
++
++- //return the best index with the largest deps
+++ // return the best index with the largest deps
++ size_t best_index_a = 0;
++ size_t best_index_u = 0;
++ int best_value_a = -1;
++ int best_value_u = -1;
++- for(i = 0; i < n_impls; i++)
++- {
+++ for (i = 0; i < n_impls; i++) {
++ const signed val = impl_deps[i];
++- if (alignment[i] && val > best_value_a)
++- {
+++ if (alignment[i] && val > best_value_a) {
++ best_index_a = i;
++ best_value_a = val;
++ }
++- if (!alignment[i] && val > best_value_u)
++- {
+++ if (!alignment[i] && val > best_value_u) {
++ best_index_u = i;
++ best_value_u = val;
++ }
++ }
++
++- //when align and we found a best aligned, use it
++- if (align && best_value_a != -1) return best_index_a;
+++ // when align and we found a best aligned, use it
+++ if (align && best_value_a != -1)
+++ return best_index_a;
++
++- //otherwise return the best unaligned
+++ // otherwise return the best unaligned
++ return best_index_u;
++ }
++diff --git a/lib/volk_rank_archs.h b/lib/volk_rank_archs.h
++index b3bf8ff..9434778 100644
++--- a/lib/volk_rank_archs.h
+++++ b/lib/volk_rank_archs.h
++@@ -22,26 +22,24 @@
++ #ifndef INCLUDED_VOLK_RANK_ARCHS_H
++ #define INCLUDED_VOLK_RANK_ARCHS_H
++
++-#include <stdlib.h>
++ #include <stdbool.h>
+++#include <stdlib.h>
++
++ #ifdef __cplusplus
++ extern "C" {
++ #endif
++
++-int volk_get_index(
++- const char *impl_names[], //list of implementations by name
++- const size_t n_impls, //number of implementations available
++- const char *impl_name //the implementation name to find
+++int volk_get_index(const char* impl_names[], // list of implementations by name
+++ const size_t n_impls, // number of implementations available
+++ const char* impl_name // the implementation name to find
++ );
++
++-int volk_rank_archs(
++- const char *kern_name, //name of the kernel to rank
++- const char *impl_names[], //list of implementations by name
++- const int* impl_deps, //requirement mask per implementation
++- const bool* alignment, //alignment status of each implementation
++- size_t n_impls, //number of implementations available
++- const bool align //if false, filter aligned implementations
+++int volk_rank_archs(const char* kern_name, // name of the kernel to rank
+++ const char* impl_names[], // list of implementations by name
+++ const int* impl_deps, // requirement mask per implementation
+++ const bool* alignment, // alignment status of each implementation
+++ size_t n_impls, // number of implementations available
+++ const bool align // if false, filter aligned implementations
++ );
++
++ #ifdef __cplusplus
++--
++2.20.1
++
projects / volk.git / commitdiff